@kici-dev/compiler 0.4.0 → 0.6.0

package/dist/local-plane/paths.js

@@ -1,5 +1,6 @@
 import "../rolldown-runtime-ClRpJifh.js";
 import path from "node:path";
+import fs from "node:fs";
 import os from "node:os";
 //#region src/local-plane/paths.ts
 /**
@@ -11,10 +12,30 @@ const PLANE_STAMP_VERSION = 3;
 /**
 * Root directory of the local dev plane's state, following the same
 * `KICI_CONFIG_DIR` → `~/.kici` convention the rest of the CLI uses.
+*
+* RESOLVED THROUGH SYMLINKS, deliberately. The plane is a singleton on fixed
+* ports, so a caller may reach it through a config dir that only symlinks
+* `local` at the durable one — `pnpm deploy:stg` does exactly that, to run
+* against a throwaway config dir carrying no credentials while still reusing
+* the warm plane.
+*
+* Without resolving, the plane's Postgres is started with a data directory
+* addressed through that ephemeral path and keeps it open. When the caller
+* removes its temp dir, Postgres PANICs — `could not open file
+* "<tmp>/local/pgdata/global/pg_control"` — and shuts the whole plane down,
+* taking every later phase with it. Resolving first means Postgres only ever
+* sees the durable path, so a caller's temp dir can come and go beneath it.
+*
+* A path that does not exist yet resolves to itself: a fresh plane creates it.
 */
 function planeRoot() {
 	const base = process.env.KICI_CONFIG_DIR ?? path.join(os.homedir(), ".kici");
-	return path.join(base, "local");
+	const root = path.join(base, "local");
+	try {
+		return fs.realpathSync(root);
+	} catch {
+		return root;
+	}
 }
 /**
 * Absolute paths for every artefact the plane persists under its state root.

package/dist/local-plane/plane-manager.js

@@ -19,8 +19,8 @@ import { generateKeyPairSync, randomBytes } from "node:crypto";
 */
 function currentBuildIdentity() {
 	return {
-		version: "0.4.0",
-		buildCommit: "ffd489464"
+		version: "0.6.0",
+		buildCommit: "e4a936029"
 	};
 }
 /**

package/dist/local-plane/port-holder.js

@@ -15,7 +15,7 @@ import net from "node:net";
 const defaultExec = (cmd, args) => new Promise((resolve) => {
 	execFile(cmd, args, {
 		timeout: 5e3,
-		maxBuffer: 8 * 1024 * 1024
+		maxBuffer: 8388608
 	}, (err, stdout) => {
 		const raw = err?.code;
 		resolve({

package/dist/local-plane/postgres.d.ts

@@ -3,7 +3,7 @@
  * `TS_CONST_PINS` in hack/containers-lock.ts (identity
  * docker.io/library/postgres+alpine), so a lock bump rewrites it in place.
  */
-export declare const PLANE_PG_IMAGE = "docker.io/library/postgres:18.4-alpine";
+export declare const PLANE_PG_IMAGE = "docker.io/library/postgres:18.6-alpine";
 /** Name of the fallback podman Postgres container. */
 export declare const PLANE_PG_CONTAINER = "kici-local-postgres";
 export type PlanePgHandle = {
@@ -11,13 +11,6 @@ export type PlanePgHandle = {
     kind: 'embedded' | 'podman';
     stop(): Promise<void>;
 };
-declare let readyPoller: typeof defaultReadyPoller;
-/** Test seam: override the podman readiness poller. */
-export declare function __setReadyPollerForTest(fn: typeof readyPoller): void;
-declare let embeddedDaemon: typeof defaultEmbeddedDaemon;
-/** Test seam: override the embedded postmaster daemonizer. */
-export declare function __setEmbeddedDaemonForTest(fn: typeof embeddedDaemon): void;
-declare function defaultReadyPoller(_port: number): Promise<boolean>;
 /**
  * Whether this plane's embedded postmaster is already serving `port`.
  *
@@ -31,13 +24,6 @@ declare function defaultReadyPoller(_port: number): Promise<boolean>;
  * one this plane can reuse.
  */
 export declare function embeddedClusterIsServing(port: number): Promise<boolean>;
-/**
- * Start a detached embedded postmaster via `pg_ctl` so it survives the exit of
- * this CLI process (embedded-postgres's in-process server is killed by its own
- * exit hook, so it cannot back a warm plane). A cluster already serving this
- * plane's port is reused as-is.
- */
-declare function defaultEmbeddedDaemon(port: number): Promise<void>;
 /**
  * Stop the plane's Postgres by backend kind. Handle-independent so a separate
  * CLI invocation (`kici local down`) can tear down what `up` started.
@@ -51,6 +37,7 @@ export declare function stopPlanePostgres(kind: 'embedded' | 'podman'): Promise<
  */
 export declare function startPlanePostgres(opts?: {
     forcePodman?: boolean;
+    readyPoller?: (port: number) => Promise<boolean>;
+    embeddedDaemon?: (port: number) => Promise<void>;
 }): Promise<PlanePgHandle>;
-export {};
 //# sourceMappingURL=postgres.d.ts.map

package/dist/local-plane/postgres.js

@@ -13,19 +13,9 @@ import EmbeddedPostgres from "embedded-postgres";
 * `TS_CONST_PINS` in hack/containers-lock.ts (identity
 * docker.io/library/postgres+alpine), so a lock bump rewrites it in place.
 */
-const PLANE_PG_IMAGE = "docker.io/library/postgres:18.4-alpine";
+const PLANE_PG_IMAGE = "docker.io/library/postgres:18.6-alpine";
 /** Name of the fallback podman Postgres container. */
 const PLANE_PG_CONTAINER = "kici-local-postgres";
-let readyPoller = defaultReadyPoller;
-/** Test seam: override the podman readiness poller. */
-function __setReadyPollerForTest(fn) {
-	readyPoller = fn;
-}
-let embeddedDaemon = defaultEmbeddedDaemon;
-/** Test seam: override the embedded postmaster daemonizer. */
-function __setEmbeddedDaemonForTest(fn) {
-	embeddedDaemon = fn;
-}
 async function defaultReadyPoller(_port) {
 	for (let i = 0; i < 60; i++) try {
 		await $`podman exec ${PLANE_PG_CONTAINER} pg_isready -U kici`.quiet();
@@ -56,7 +46,8 @@ function resolvePgCtl() {
 		"win32:x64": "@embedded-postgres/windows-x64"
 	}[`${platform}:${arch}`];
 	if (!pkg) throw new Error(`unsupported platform for embedded Postgres: ${platform}/${arch}`);
-	const entry = createRequire(createRequire(import.meta.url).resolve("embedded-postgres")).resolve(pkg);
+	const require = createRequire(import.meta.url);
+	const entry = createRequire(require.resolve("embedded-postgres")).resolve(pkg);
 	const binName = platform === "win32" ? "pg_ctl.exe" : "pg_ctl";
 	return path.resolve(path.dirname(entry), "..", "native", "bin", binName);
 }
@@ -119,13 +110,15 @@ async function embeddedClusterIsServing(port) {
 async function defaultEmbeddedDaemon(port) {
 	const { pgData, logFile } = planePaths();
 	if (await embeddedClusterIsServing(port)) return;
-	await $`${resolvePgCtl()} -D ${pgData} -o ${`-p ${port}`} -l ${`${logFile}.pg`} -w start`.quiet();
+	const pgCtl = resolvePgCtl();
+	await $`${pgCtl} -D ${pgData} -o ${`-p ${port}`} -l ${`${logFile}.pg`} -w start`.quiet();
 }
 /** Stop the detached embedded postmaster (handle-independent, reads the data dir). */
 async function stopEmbeddedDaemon() {
 	const { pgData } = planePaths();
 	if (!fs.existsSync(path.join(pgData, "postmaster.pid"))) return;
-	await $`${resolvePgCtl()} -D ${pgData} stop -m fast`.quiet().catch(() => {});
+	const pgCtl = resolvePgCtl();
+	await $`${pgCtl} -D ${pgData} stop -m fast`.quiet().catch(() => {});
 }
 /**
 * Stop the plane's Postgres by backend kind. Handle-independent so a separate
@@ -142,6 +135,8 @@ async function stopPlanePostgres(kind) {
 * (or when forced via `forcePodman` / `KICI_LOCAL_PG_MODE=podman`).
 */
 async function startPlanePostgres(opts = {}) {
+	const readyPoller = opts.readyPoller ?? defaultReadyPoller;
+	const embeddedDaemon = opts.embeddedDaemon ?? defaultEmbeddedDaemon;
 	const { postgres: port } = planePorts();
 	const url = `postgres://kici:kici@127.0.0.1:${port}/kici_local`;
 	if (!(opts.forcePodman || process.env.KICI_LOCAL_PG_MODE === "podman")) try {
@@ -182,6 +177,6 @@ async function startPlanePostgres(opts = {}) {
 	};
 }
 //#endregion
-export { PLANE_PG_CONTAINER, PLANE_PG_IMAGE, __setEmbeddedDaemonForTest, __setReadyPollerForTest, embeddedClusterIsServing, startPlanePostgres, stopPlanePostgres };
+export { PLANE_PG_CONTAINER, PLANE_PG_IMAGE, embeddedClusterIsServing, startPlanePostgres, stopPlanePostgres };
 
 //# sourceMappingURL=postgres.js.map

package/dist/lockfile/generator.d.ts

@@ -36,6 +36,18 @@ export declare function detectGitRoot(): string;
  * For yarn the prefix also carries the flavor (`yarn-classic` / `yarn-berry`),
  * so a classic-layout dep-cache tarball is never restored into a berry install.
  *
+ * The detected manager only orders the search; it never restricts it. Detection
+ * falls back to the AMBIENT `npm_config_user_agent` when a directory carries no
+ * signal of its own, so a repo whose root holds neither a `package.json` nor a
+ * lockfile is reported as whatever manager happened to invoke the compiler. A
+ * repo compiled under pnpm that keeps an npm `.kici/package-lock.json` was
+ * therefore searched for `pnpm-lock.yaml` only, found none, and got no hash at
+ * all — which silently disables the orchestrator's dependency cache for it, so
+ * every agent installs from the registry and an agent with no registry route
+ * cannot run the job at all. Searching every manager's candidates after the
+ * detected one's keeps the detected manager authoritative where it has real
+ * evidence, and still finds the lockfile that is actually on disk.
+ *
  * @param gitRoot - Absolute path to git repository root
  * @returns Hex SHA-256 hash string, or null if no lockfile is found
  */

package/dist/lockfile/generator.js

@@ -5,13 +5,13 @@ import "../errors/index.js";
 import { BREAKING_FLOOR as BREAKING_FLOOR$1, SCHEMA_VERSION as SCHEMA_VERSION$1 } from "../types.js";
 import { computeContentHash } from "./hasher.js";
 import { resolveHashFiles } from "./hash-files.js";
-import { analyzePurity } from "./purity-analyzer.js";
 import path from "node:path";
 import { readFileSync } from "node:fs";
 import { getDynamicJobGroup, getDynamicJobNeeds, isDynamicFunction, isDynamicGroupRef, isDynamicJobFn, isParallelGroup, isStaticArray, isStaticObject, normalizeApproval, normalizeCacheSpecs } from "@kici-dev/sdk";
 import { sha256 } from "@kici-dev/core";
 import { PackageManager, detectPackageManagerSync, detectYarnFlavorSync } from "@kici-dev/core/package-manager";
-import { assertScheduleInputsSatisfiable, extractInputsDescriptorMap, resolveWhenToRunOn, validateResourceRequest } from "@kici-dev/engine";
+import { assertScheduleInputsSatisfiable, extractInputsDescriptorMap, resolveContentFormat, resolveWhenToRunOn, validateResourceRequest } from "@kici-dev/engine";
+import { assertSafeRegex } from "@kici-dev/engine/safe-regex";
 import { normalizeRunsOnAllToMatchers, normalizeRunsOnToMatchers, runsOnPickFromInput } from "@kici-dev/engine/labels/compile";
 import { execSync } from "node:child_process";
 //#region src/lockfile/generator.ts
@@ -66,16 +66,39 @@ function detectGitRoot() {
 * For yarn the prefix also carries the flavor (`yarn-classic` / `yarn-berry`),
 * so a classic-layout dep-cache tarball is never restored into a berry install.
 *
+* The detected manager only orders the search; it never restricts it. Detection
+* falls back to the AMBIENT `npm_config_user_agent` when a directory carries no
+* signal of its own, so a repo whose root holds neither a `package.json` nor a
+* lockfile is reported as whatever manager happened to invoke the compiler. A
+* repo compiled under pnpm that keeps an npm `.kici/package-lock.json` was
+* therefore searched for `pnpm-lock.yaml` only, found none, and got no hash at
+* all — which silently disables the orchestrator's dependency cache for it, so
+* every agent installs from the registry and an agent with no registry route
+* cannot run the job at all. Searching every manager's candidates after the
+* detected one's keeps the detected manager authoritative where it has real
+* evidence, and still finds the lockfile that is actually on disk.
+*
 * @param gitRoot - Absolute path to git repository root
 * @returns Hex SHA-256 hash string, or null if no lockfile is found
 */
 function computeLockfileHash(gitRoot) {
 	const pm = detectPackageManagerSync(gitRoot) === PackageManager.Npm ? detectPackageManagerSync(path.join(gitRoot, ".kici")) : detectPackageManagerSync(gitRoot);
-	const candidates = pm === PackageManager.Pnpm ? [path.join(gitRoot, "pnpm-lock.yaml"), path.join(gitRoot, ".kici", "pnpm-lock.yaml")] : pm === PackageManager.Yarn ? [path.join(gitRoot, "yarn.lock"), path.join(gitRoot, ".kici", "yarn.lock")] : [path.join(gitRoot, ".kici", "package-lock.json")];
-	const prefix = pm === PackageManager.Yarn ? `${pm}-${detectYarnFlavorSync(detectPackageManagerSync(gitRoot) === PackageManager.Yarn ? gitRoot : path.join(gitRoot, ".kici"))}` : pm;
-	for (const lockfilePath of candidates) try {
-		return sha256(`${prefix}\n${readFileSync(lockfilePath, "utf-8")}`);
-	} catch {}
+	const byManager = (m) => m === PackageManager.Pnpm ? [path.join(gitRoot, "pnpm-lock.yaml"), path.join(gitRoot, ".kici", "pnpm-lock.yaml")] : m === PackageManager.Yarn ? [path.join(gitRoot, "yarn.lock"), path.join(gitRoot, ".kici", "yarn.lock")] : [path.join(gitRoot, ".kici", "package-lock.json")];
+	const order = [pm, ...[
+		PackageManager.Npm,
+		PackageManager.Pnpm,
+		PackageManager.Yarn
+	].filter((m) => m !== pm)];
+	for (const manager of order) for (const lockfilePath of byManager(manager)) {
+		let content;
+		try {
+			content = readFileSync(lockfilePath, "utf-8");
+		} catch {
+			continue;
+		}
+		const prefix = manager === PackageManager.Yarn ? `${manager}-${detectYarnFlavorSync(path.dirname(lockfilePath))}` : manager;
+		return sha256(`${prefix}\n${content}`);
+	}
 	return null;
 }
 /**
@@ -112,16 +135,17 @@ function generateLockFile(workflowsWithSource) {
 	const workflows = workflowsWithSource.map(({ workflow, source, bundleSource }) => {
 		return transformWorkflow(workflow, path.relative(gitRoot, source.file).replaceAll("\\", "/"), formatExportRef(source), bundleSource, gitRoot);
 	});
+	const contentHash = sha256(JSON.stringify({
+		schemaVersion: SCHEMA_VERSION$1,
+		minReaderVersion: BREAKING_FLOOR$1,
+		source: topLevelSource,
+		workflows
+	}));
 	return {
 		schemaVersion: SCHEMA_VERSION$1,
 		minReaderVersion: BREAKING_FLOOR$1,
 		source: topLevelSource,
-		contentHash: sha256(JSON.stringify({
-			schemaVersion: SCHEMA_VERSION$1,
-			minReaderVersion: BREAKING_FLOOR$1,
-			source: topLevelSource,
-			workflows
-		})),
+		contentHash,
 		...lockfileHash && { lockfileHash },
 		workflows
 	};
@@ -178,7 +202,8 @@ function transformWorkflow(workflow, sourceFile, exportRef, bundleSource, gitRoo
 			...workflow.concurrency.max !== void 0 && { max: workflow.concurrency.max }
 		} },
 		...workflow.timeout !== void 0 && { timeout: workflow.timeout },
-		...workflow.approval !== void 0 && { approval: (assertNonStepApprovalScope(workflow.approval, "workflow", locationForWorkflow(sourceFile)), toLockApproval(workflow.approval)) }
+		...workflow.approval !== void 0 && { approval: (assertNonStepApprovalScope(workflow.approval, "workflow", locationForWorkflow(sourceFile)), toLockApproval(workflow.approval)) },
+		...typeof workflow.filter === "function" && { hasFilter: true }
 	};
 }
 /**
@@ -189,6 +214,116 @@ function transformWorkflow(workflow, sourceFile, exportRef, bundleSource, gitRoo
 function reposField(trigger) {
 	return trigger.repos && trigger.repos.length > 0 ? { repos: transformBranchPatterns(trigger.repos) } : {};
 }
+/** Normalize a scalar-or-array SDK value to an array. */
+function toArray(v) {
+	if (v === void 0) return [];
+	return Array.isArray(v) ? v : [v];
+}
+/**
+* Normalize one regex entry to the lock's `/pattern/flags` form, rejecting an
+* invalid or ReDoS-prone pattern at compile time so a catastrophic pattern fails
+* `kici compile` with author feedback instead of reaching the orchestrator.
+*/
+function serializeRegexEntry(entry, ctx) {
+	const source = entry instanceof RegExp ? `/${entry.source}/${entry.flags}` : entry;
+	const wrapped = /^\/(.+)\/([gimsuy]*)$/.exec(source);
+	const pattern = wrapped ? wrapped[1] : source;
+	const flags = wrapped ? wrapped[2] : "";
+	let re;
+	try {
+		re = new RegExp(pattern, flags);
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw compilerError("E123", `${ctx}: invalid regex — ${reason}`);
+	}
+	try {
+		assertSafeRegex(re.source, re.flags, ctx);
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		throw compilerError("E123", `${ctx}: ${reason}`);
+	}
+	return `/${re.source}/${re.flags}`;
+}
+/**
+* Serialize a {@link TextMatch} to its lock form: every key normalized to a flat
+* array, every regex to `/pattern/flags`, every degenerate shape rejected.
+*
+* `ctx` is a human label woven into any thrown error (e.g. `push trigger
+* 'commitMessage'`, `requires 'Dockerfile'`).
+*/
+function serializeTextMatch(m, ctx) {
+	const contains = toArray(m.contains);
+	const notContains = toArray(m.notContains);
+	const matches = toArray(m.matches);
+	const notMatches = toArray(m.notMatches);
+	if (contains.length === 0 && notContains.length === 0 && matches.length === 0 && notMatches.length === 0) throw compilerError("E122", `${ctx}: no query key (contains/notContains/matches/notMatches) — nothing to check`);
+	for (const needle of [...contains, ...notContains]) if (needle === "") throw compilerError("E122", `${ctx}: an empty needle matches every text — remove it`);
+	if (m.ignoreCase !== void 0 && contains.length === 0 && notContains.length === 0) throw compilerError("E122", `${ctx}: 'ignoreCase' affects only contains/notContains — a regex carries its own flags`);
+	return {
+		...contains.length > 0 && { contains: [...contains] },
+		...notContains.length > 0 && { notContains: [...notContains] },
+		...matches.length > 0 && { matches: matches.map((e) => serializeRegexEntry(e, ctx)) },
+		...notMatches.length > 0 && { notMatches: notMatches.map((e) => serializeRegexEntry(e, ctx)) },
+		...m.ignoreCase !== void 0 && { ignoreCase: m.ignoreCase }
+	};
+}
+/** Emit the optional `commitMessage` field for a git-event lock trigger. */
+function commitMessageField(commitMessage, triggerLabel) {
+	if (commitMessage === void 0) return {};
+	return { commitMessage: serializeTextMatch(commitMessage, `${triggerLabel} 'commitMessage'`) };
+}
+/**
+* Serialize one SDK content requirement into its lock form, validating and
+* resolving `format: 'auto'` by extension at compile time. A malformed filter
+* throws (fails `kici compile`) rather than reaching the orchestrator.
+*/
+function serializeOneRequirement(req) {
+	const hasJsonQuery = req.exists !== void 0 && req.exists.length > 0 || req.match !== void 0 && Object.keys(req.match).length > 0 || req.not !== void 0 && Object.keys(req.not).length > 0;
+	const textKeys = {
+		...req.contains !== void 0 && { contains: req.contains },
+		...req.notContains !== void 0 && { notContains: req.notContains },
+		...req.matches !== void 0 && { matches: req.matches },
+		...req.notMatches !== void 0 && { notMatches: req.notMatches },
+		...req.ignoreCase !== void 0 && { ignoreCase: req.ignoreCase }
+	};
+	const hasTextQuery = req.contains !== void 0 || req.notContains !== void 0 || req.matches !== void 0 || req.notMatches !== void 0;
+	const hasAnyQuery = hasJsonQuery || hasTextQuery || req.ignoreCase !== void 0;
+	if (req.absent) {
+		if (hasAnyQuery) throw compilerError("E118", `requires '${req.file}': 'absent' is mutually exclusive with query keys (exists/match/not/contains/notContains/matches/notMatches)`);
+		return {
+			file: req.file,
+			absent: true
+		};
+	}
+	const format = resolveContentFormat(req.file, req.format);
+	if (format === "text" && hasJsonQuery) throw compilerError("E119", `requires '${req.file}': text format cannot carry a json/yaml query key (exists/match/not) — name a .json/.yaml file or set format: 'json' | 'yaml'`);
+	if (format !== "text" && (hasTextQuery || req.ignoreCase !== void 0)) throw compilerError("E119", `requires '${req.file}': '${format}' format cannot carry a raw-text key (contains/notContains/matches/notMatches/ignoreCase) — use format: 'text'`);
+	if (!hasAnyQuery) {
+		if (req.format !== void 0) throw compilerError("E122", `requires '${req.file}': format '${req.format}' declared with no query key — nothing to check`);
+		return { file: req.file };
+	}
+	const text = hasTextQuery ? serializeTextMatch(textKeys, `requires '${req.file}'`) : {};
+	return {
+		file: req.file,
+		format,
+		...req.exists !== void 0 && { exists: req.exists },
+		...req.match !== void 0 && { match: req.match },
+		...req.not !== void 0 && { not: req.not },
+		...text
+	};
+}
+/**
+* Serialize a trigger's `requires` list, or `undefined` when empty (so the lock
+* field stays absent). Each entry is validated + format-resolved at compile time.
+*/
+function serializeRequires(requires) {
+	if (!requires || requires.length === 0) return void 0;
+	return requires.map(serializeOneRequirement);
+}
+function requiresField(requires) {
+	const serialized = serializeRequires(requires);
+	return serialized ? { requires: serialized } : {};
+}
 function toLockPr(t) {
 	return {
 		_type: "pr",
@@ -196,19 +331,27 @@ function toLockPr(t) {
 		targetBranches: transformBranchPatterns(t.targetBranches),
 		sourceBranches: transformBranchPatterns(t.sourceBranches),
 		paths: t.paths,
-		...reposField(t)
+		...reposField(t),
+		...requiresField(t.requires),
+		...commitMessageField(t.commitMessage, "pr trigger")
 	};
 }
 function toLockPushAndTag(t) {
+	const requires = requiresField(t.requires);
+	const commitMessage = commitMessageField(t.commitMessage, "push trigger");
 	const results = [{
 		_type: "push",
 		branches: transformBranchPatterns(t.branches),
 		paths: t.paths,
-		...reposField(t)
+		...reposField(t),
+		...requires,
+		...commitMessage
 	}];
 	if (t.tags.length > 0) results.push({
 		_type: "tag",
-		patterns: transformBranchPatterns(t.tags)
+		patterns: transformBranchPatterns(t.tags),
+		...requires,
+		...commitMessage
 	});
 	return results;
 }
@@ -216,7 +359,9 @@ function toLockTag(t) {
 	return {
 		_type: "tag",
 		patterns: transformBranchPatterns(t.patterns),
-		...reposField(t)
+		...reposField(t),
+		...requiresField(t.requires),
+		...commitMessageField(t.commitMessage, "tag trigger")
 	};
 }
 function toLockComment(t) {
@@ -518,25 +663,15 @@ function validateRunsOn(runsOn, jobName, location) {
 }
 /**
 * Transform one context reference (static name or function) into a lock
-* `{ value, dynamic }` entry. A function element is analyzed for purity: a pure
-* function becomes an inline expression resolvable at two-phase eval; an impure
-* one carries only the `dynamic` flag (the agent runs an init job to resolve it).
+* `{ value, dynamic }` entry. A function element carries only the `dynamic`
+* flag (the agent resolves it in the init round); a static name carries its
+* literal value.
 */
 function transformContextRef(ref) {
-	if (typeof ref === "function") {
-		const fnSource = ref.toString();
-		if (analyzePurity(fnSource).pure) return {
-			value: {
-				_type: "inline",
-				expression: fnSource
-			},
-			dynamic: true
-		};
-		return {
-			value: "",
-			dynamic: true
-		};
-	}
+	if (typeof ref === "function") return {
+		value: "",
+		dynamic: true
+	};
 	return {
 		value: ref,
 		dynamic: false
@@ -551,7 +686,7 @@ function transformJob(job, configPath, index, gitRoot, uuidToName) {
 		location: jobLocation,
 		suggestion: "Set exactly one of runsOn (single agent) or runsOnAll (fan-out to every matching agent)."
 	});
-	if (job.runsOn === void 0 && job.runsOnAll === void 0) throw compilerError("E109", `job '${job.name}': one of runsOn or runsOnAll is required`, {
+	if (job.invoke === void 0 && job.runsOn === void 0 && job.runsOnAll === void 0) throw compilerError("E109", `job '${job.name}': one of runsOn or runsOnAll is required`, {
 		location: jobLocation,
 		suggestion: "Add runsOn: \"kici:os:linux\" (or another agent label) to the job."
 	});
@@ -567,15 +702,8 @@ function transformJob(job, configPath, index, gitRoot, uuidToName) {
 	if (contextRefs !== void 0 && contextRefs.length > 0) contextFields.contexts = contextRefs.map((ref) => transformContextRef(ref));
 	const envFields = {};
 	if (job.env !== void 0) {
-		if (typeof job.env === "function") {
-			const fnSource = job.env.toString();
-			const purity = analyzePurity(fnSource);
-			envFields.dynamicEnv = true;
-			if (purity.pure) envFields.env = {
-				_type: "inline",
-				expression: fnSource
-			};
-		} else if (typeof job.env === "object") envFields.env = { ...job.env };
+		if (typeof job.env === "function") envFields.dynamicEnv = true;
+		else if (typeof job.env === "object") envFields.env = { ...job.env };
 	}
 	if (job.resources !== void 0) try {
 		validateResourceRequest(job.resources);
@@ -588,15 +716,8 @@ function transformJob(job, configPath, index, gitRoot, uuidToName) {
 	}
 	const concurrencyFields = {};
 	if (job.concurrencyGroup !== void 0) {
-		if (typeof job.concurrencyGroup === "function") {
-			const fnSource = job.concurrencyGroup.toString();
-			const purity = analyzePurity(fnSource);
-			concurrencyFields.dynamicConcurrencyGroup = true;
-			if (purity.pure) concurrencyFields.concurrencyGroup = {
-				_type: "inline",
-				expression: fnSource
-			};
-		} else if (typeof job.concurrencyGroup === "string") concurrencyFields.concurrencyGroup = job.concurrencyGroup;
+		if (typeof job.concurrencyGroup === "function") concurrencyFields.dynamicConcurrencyGroup = true;
+		else if (typeof job.concurrencyGroup === "string") concurrencyFields.concurrencyGroup = job.concurrencyGroup;
 	}
 	return {
 		_type: "static",
@@ -605,8 +726,15 @@ function transformJob(job, configPath, index, gitRoot, uuidToName) {
 		...job.runsOnAll !== void 0 && { runsOnAll: normalizeRunsOnAllToMatchers(job.runsOnAll, `job '${job.name}' runsOnAll`) },
 		...job.onUnreachable !== void 0 && { onUnreachable: job.onUnreachable },
 		...job.includeUninitialized !== void 0 && { includeUninitialized: job.includeUninitialized },
+		...job.gitCredentials !== void 0 && { gitCredentials: job.gitCredentials },
 		...job.maxParallel !== void 0 && { maxParallel: job.maxParallel },
 		...job.failFast !== void 0 && { failFast: job.failFast },
+		...job.invoke !== void 0 && { invoke: {
+			event: job.invoke.event,
+			scope: job.invoke.scope,
+			...job.invoke.payload !== void 0 && { payload: job.invoke.payload },
+			...job.invoke.optional === true && { optional: true }
+		} },
 		...resolveNeedsForLock(job.needs, uuidToName),
 		steps: transformSteps(job.steps, gitRoot, jobLocation),
 		matrix: job.matrix ? transformMatrix(job.matrix, job.name, configPath) : void 0,

package/dist/lockfile/index.d.ts

@@ -1,5 +1,3 @@
 export { generateLockFile, serializeLockFile, detectGitRoot, computeLockfileHash, schemaWindowWarning, } from './generator.js';
 export { computeContentHash, COMPILE_SCHEMA_VERSION } from './hasher.js';
-export { DynamicValueField, analyzeJobPurity, collectWorkflowPurityWarnings, } from './purity-diagnostics.js';
-export type { JobPurityWarning } from './purity-diagnostics.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/lockfile/index.js

@@ -1,5 +1,4 @@
 import "../rolldown-runtime-ClRpJifh.js";
 import { COMPILE_SCHEMA_VERSION, computeContentHash } from "./hasher.js";
 import { computeLockfileHash, detectGitRoot, generateLockFile, schemaWindowWarning, serializeLockFile } from "./generator.js";
-import { DynamicValueField, analyzeJobPurity, collectWorkflowPurityWarnings } from "./purity-diagnostics.js";
-export { COMPILE_SCHEMA_VERSION, DynamicValueField, analyzeJobPurity, collectWorkflowPurityWarnings, computeContentHash, computeLockfileHash, detectGitRoot, generateLockFile, schemaWindowWarning, serializeLockFile };
+export { COMPILE_SCHEMA_VERSION, computeContentHash, computeLockfileHash, detectGitRoot, generateLockFile, schemaWindowWarning, serializeLockFile };

package/dist/postinstall.js

@@ -26,7 +26,8 @@ async function detectDevelopmentMode() {
 	if (process.env.KICI_DEV === "true") return true;
 	try {
 		const rootDir = process.env.INIT_CWD || process.cwd();
-		const content = await readFile(path.join(rootDir, "package.json"), "utf-8");
+		const rootPkgPath = path.join(rootDir, "package.json");
+		const content = await readFile(rootPkgPath, "utf-8");
 		return JSON.parse(content).kici?.development === true;
 	} catch {
 		return false;

package/dist/remote/config.d.ts

@@ -35,22 +35,9 @@ export interface GlobalConfig {
  *
  * Resolution order:
  *   1. `KICI_CONFIG_DIR`, when set to a non-empty value.
- *   2. A hard refusal when `KICI_TEST_ISOLATION` is present. A developer
- *      machine's `~/.kici/config` names a real endpoint and carries a live
- *      PAT, so a test process that reads it authenticates against whatever
- *      that config points at — in practice, production. Every test that needs
- *      a config must name its own isolated directory.
- *   3. `~/.kici`.
+ *   2. `~/.kici`.
  *
- * `KICI_TEST_ISOLATION` is set by this repository's own vitest configs, via
- * `hack/lib/vitest-isolation.ts`. It is deliberately a KiCI-owned name rather
- * than the runner's `VITEST`: `kici` is a compat-protected CLI, and `VITEST`
- * is a third-party marker that propagates into spawned children, so keying off
- * it would break a customer whose vitest test shells out to `kici`.
- *
- * `env` is injectable so this module's own tests can exercise every branch.
- * It is NOT an opt-out: production call sites pass no argument and inherit the
- * guard.
+ * `env` is injectable so this module's own tests can exercise both branches.
  */
 export declare function getConfigDir(env?: NodeJS.ProcessEnv): string;
 /**

package/dist/remote/config.js

@@ -33,26 +33,12 @@ function sanitizeConfig(raw) {
 *
 * Resolution order:
 *   1. `KICI_CONFIG_DIR`, when set to a non-empty value.
-*   2. A hard refusal when `KICI_TEST_ISOLATION` is present. A developer
-*      machine's `~/.kici/config` names a real endpoint and carries a live
-*      PAT, so a test process that reads it authenticates against whatever
-*      that config points at — in practice, production. Every test that needs
-*      a config must name its own isolated directory.
-*   3. `~/.kici`.
+*   2. `~/.kici`.
 *
-* `KICI_TEST_ISOLATION` is set by this repository's own vitest configs, via
-* `hack/lib/vitest-isolation.ts`. It is deliberately a KiCI-owned name rather
-* than the runner's `VITEST`: `kici` is a compat-protected CLI, and `VITEST`
-* is a third-party marker that propagates into spawned children, so keying off
-* it would break a customer whose vitest test shells out to `kici`.
-*
-* `env` is injectable so this module's own tests can exercise every branch.
-* It is NOT an opt-out: production call sites pass no argument and inherit the
-* guard.
+* `env` is injectable so this module's own tests can exercise both branches.
 */
 function getConfigDir(env = process.env) {
 	if (env.KICI_CONFIG_DIR) return env.KICI_CONFIG_DIR;
-	if (env.KICI_TEST_ISOLATION) throw new Error("Refusing to read the ambient ~/.kici config from a test process. Set KICI_CONFIG_DIR to an isolated directory for this run — the developer machine config may point at production.");
 	return path.join(os.homedir(), ".kici");
 }
 /**