@kici-dev/sdk 0.5.0 → 0.6.1

package/dist/invoke.js

@@ -0,0 +1,27 @@
+import "./rolldown-runtime-ClRpJifh.js";
+import { reservedEventNamePrefix } from "@kici-dev/engine";
+//#region src/invoke.ts
+/**
+* Invoke the source repo's opt-in workflows and gate on them.
+*
+* Targets exactly `ctx.sourceRepo`, so a global workflow can hand control back to
+* the repo whose event triggered it without any org-wide fan-out. Subscribers opt
+* in with `kiciEvent({ name })`. Required by default: if no workflow subscribes,
+* the gate fails unless `optional: true` is set.
+*/
+function invokeSource(event, opts) {
+	if (typeof event !== "string" || event.trim().length === 0) throw new Error("invokeSource: event name must be a non-empty string");
+	const reservedPrefix = reservedEventNamePrefix(event);
+	if (reservedPrefix) throw new Error(`invokeSource: event name prefix "${reservedPrefix}" is reserved for KiCI internal events (got "${event}")`);
+	return Object.freeze({
+		_tag: "InvokeSource",
+		event,
+		scope: "source",
+		...opts?.payload !== void 0 && { payload: Object.freeze({ ...opts.payload }) },
+		...opts?.optional === true && { optional: true }
+	});
+}
+//#endregion
+export { invokeSource };
+
+//# sourceMappingURL=invoke.js.map

package/dist/job-outputs.test-d.js

@@ -1,30 +1,34 @@
 import "./rolldown-runtime-ClRpJifh.js";
 import { isHostJobOutputs, isMatrixJobOutputs } from "./context.js";
 import { dynamicGroup } from "./dynamic-group.js";
-import { step } from "./step.js";
-import { job } from "./job.js";
 import { workflow } from "./workflow.js";
+import { job } from "./job.js";
+import { step } from "./step.js";
 import { describe, expectTypeOf, it } from "vitest";
 //#region src/job-outputs.test-d.ts
 describe("Job<TOutputs> — merged-steps inference", () => {
 	it("infers a nested output map keyed by step name for a multi-step job", () => {
+		const build = step("build", { run: async () => ({ version: "1.0" }) });
+		const test_ = step("test", { run: async () => ({ passed: true }) });
 		const j = job("ci", {
 			runsOn: "kici:os:linux",
-			steps: [step("build", { run: async () => ({ version: "1.0" }) }), step("test", { run: async () => ({ passed: true }) })]
+			steps: [build, test_]
 		});
 		expectTypeOf(j.result.build.version).toEqualTypeOf();
 		expectTypeOf(j.result.test.passed).toEqualTypeOf();
 	});
 	it("rejects reading an unknown output field of a declared step", () => {
+		const build = step("build", { run: async () => ({ version: "1.0" }) });
 		job("ci", {
 			runsOn: "kici:os:linux",
-			steps: [step("build", { run: async () => ({ version: "1.0" }) })]
+			steps: [build]
 		}).result.build.nope;
 	});
 	it("rejects reading an undeclared step name", () => {
+		const build = step("build", { run: async () => ({ version: "1.0" }) });
 		job("ci", {
 			runsOn: "kici:os:linux",
-			steps: [step("build", { run: async () => ({ version: "1.0" }) })]
+			steps: [build]
 		}).result.other;
 	});
 	it("infers a flat output shape for the run: shorthand", () => {
@@ -36,22 +40,26 @@ describe("Job<TOutputs> — merged-steps inference", () => {
 		flat.result.nope;
 	});
 	it("honours an explicit output-type override for a dynamically-shaped job", () => {
-		expectTypeOf(job("dyn", {
+		const dyn = job("dyn", {
 			runsOn: "kici:os:linux",
 			steps: [step(async () => ({}))]
-		}).result.n).toEqualTypeOf();
+		});
+		expectTypeOf(dyn.result.n).toEqualTypeOf();
 	});
 	it("omits id-less steps and falls back to the loose shape", () => {
-		expectTypeOf(job("idless", {
+		const j = job("idless", {
 			runsOn: "kici:os:linux",
 			steps: [step(async () => ({ x: 1 }))]
-		}).result.anything).toEqualTypeOf();
+		});
+		expectTypeOf(j.result.anything).toEqualTypeOf();
 	});
 	it("keeps a typed job assignable to the bare Job type", () => {
-		expectTypeOf(job("ci", {
+		const build = step("build", { run: async () => ({ version: "1.0" }) });
+		const anyJob = job("ci", {
 			runsOn: "kici:os:linux",
-			steps: [step("build", { run: async () => ({ version: "1.0" }) })]
-		})).toEqualTypeOf();
+			steps: [build]
+		});
+		expectTypeOf(anyJob).toEqualTypeOf();
 	});
 });
 describe("Job<void> — void run-shorthand assignability", () => {
@@ -75,10 +83,11 @@ describe("Job<void> — void run-shorthand assignability", () => {
 		workflow("wf", { jobs: [setup] });
 	});
 	it("resolves result to never for a void run-shorthand job", () => {
-		expectTypeOf(job("setup", {
+		const setup = job("setup", {
 			runsOn: "kici:os:linux",
 			run: async () => {}
-		}).result).toEqualTypeOf();
+		});
+		expectTypeOf(setup.result).toEqualTypeOf();
 	});
 	it("leaves a value-returning run job untouched (regression guard)", () => {
 		const flat = job("flat", {
@@ -90,9 +99,11 @@ describe("Job<void> — void run-shorthand assignability", () => {
 	});
 });
 describe("typed ctx.needs from job references", () => {
+	const build = step("build", { run: async () => ({ version: "1.0" }) });
+	const test_ = step("test", { run: async () => ({ passed: true }) });
 	const ci = job("ci", {
 		runsOn: "kici:os:linux",
-		steps: [step("build", { run: async () => ({ version: "1.0" }) }), step("test", { run: async () => ({ passed: true }) })]
+		steps: [build, test_]
 	});
 	it("threads a referenced job’s inferred outputs into ctx.needs", () => {
 		job("deploy", {
@@ -135,13 +146,15 @@ describe("typed ctx.needs from job references", () => {
 	});
 });
 describe("envelope-generic jobOutputs for typed refs", () => {
+	const build = step("build", { run: async () => ({ version: "1.0" }) });
 	const ci = job("ci", {
 		runsOn: "kici:os:linux",
-		steps: [step("build", { run: async () => ({ version: "1.0" }) })]
+		steps: [build]
 	});
 	const ctx = null;
 	it("types a job-ref jobOutputs as the plain | matrix | host union of the inferred shape", () => {
-		expectTypeOf(ctx.jobOutputs(ci)).toEqualTypeOf();
+		const out = ctx.jobOutputs(ci);
+		expectTypeOf(out).toEqualTypeOf();
 	});
 	it("narrows to the typed matrix envelope via isMatrixJobOutputs", () => {
 		const out = ctx.jobOutputs(ci);
@@ -155,7 +168,8 @@ describe("envelope-generic jobOutputs for typed refs", () => {
 		if (isHostJobOutputs(out)) expectTypeOf(out.byHost).toEqualTypeOf();
 	});
 	it("keeps a string-name ref on the loose union", () => {
-		expectTypeOf(ctx.jobOutputs({ name: "ci" })).toEqualTypeOf();
+		const out = ctx.jobOutputs({ name: "ci" });
+		expectTypeOf(out).toEqualTypeOf();
 	});
 });
 //#endregion

package/dist/job.js

@@ -1,5 +1,6 @@
 import "./rolldown-runtime-ClRpJifh.js";
 import { createJobOutputProxy } from "./outputs.js";
+import { assertSecretName } from "./git-types.js";
 import { isKnownCapability } from "@kici-dev/engine";
 import { randomUUID } from "node:crypto";
 //#region src/job.ts
@@ -38,6 +39,7 @@ function validateSandbox(sandbox, jobName) {
 function job(nameOrOptions, maybeOptions) {
 	const name = typeof nameOrOptions === "string" ? nameOrOptions : randomUUID();
 	const options = typeof nameOrOptions === "string" ? maybeOptions : nameOrOptions;
+	if (options.invoke && ((options.steps?.length ?? 0) > 0 || "run" in options)) throw new Error(`job('${name}'): 'invoke' is mutually exclusive with 'steps'/'run'`);
 	let steps = options.steps ?? [];
 	if (options.run) {
 		if (options.steps && options.steps.length > 0) throw new Error("job() cannot have both \"run\" and \"steps\" -- use one or the other");
@@ -49,7 +51,10 @@ function job(nameOrOptions, maybeOptions) {
 	const concurrencyGroup = options.concurrencyGroup ?? (typeof firstContext === "string" ? firstContext : void 0);
 	if (options.context !== void 0 && options.contexts !== void 0) throw new Error(`job('${name}'): context and contexts are mutually exclusive — use one`);
 	if (options.runsOn !== void 0 && options.runsOnAll !== void 0) throw new Error(`job('${name}'): runsOn and runsOnAll are mutually exclusive`);
-	if (options.runsOn === void 0 && options.runsOnAll === void 0) throw new Error(`job('${name}'): one of runsOn or runsOnAll is required`);
+	if (options.container !== void 0) validateContainerImageSource(name, options.container);
+	if (options.container && typeof options.container === "object" && options.container.auth) validateContainerAuth(name, options.container.auth);
+	if (options.gitCredentials) validateGitCredentials(name, options.gitCredentials);
+	if (options.invoke === void 0 && options.runsOn === void 0 && options.runsOnAll === void 0) throw new Error(`job('${name}'): one of runsOn or runsOnAll is required`);
 	if (options.onUnreachable !== void 0 && options.runsOnAll === void 0) console.warn(`[kici] job('${name}'): onUnreachable is ignored without runsOnAll`);
 	if (options.includeUninitialized !== void 0 && options.runsOnAll === void 0) console.warn(`[kici] job('${name}'): includeUninitialized is ignored without runsOnAll`);
 	return {
@@ -61,6 +66,7 @@ function job(nameOrOptions, maybeOptions) {
 		...options.includeUninitialized !== void 0 && { includeUninitialized: options.includeUninitialized },
 		...options.maxParallel !== void 0 && { maxParallel: options.maxParallel },
 		...options.failFast !== void 0 && { failFast: options.failFast },
+		...options.invoke !== void 0 && { invoke: options.invoke },
 		steps,
 		needs: options.needs,
 		rules: options.rules,
@@ -69,6 +75,7 @@ function job(nameOrOptions, maybeOptions) {
 		include: options.include,
 		exclude: options.exclude,
 		checkout: options.checkout,
+		...options.gitCredentials && { gitCredentials: options.gitCredentials },
 		container: options.container,
 		...options.sandbox !== void 0 && { sandbox: options.sandbox },
 		context: options.context,
@@ -90,6 +97,91 @@ function job(nameOrOptions, maybeOptions) {
 		result: createJobOutputProxy(name)
 	};
 }
+/**
+* Validate a job's named git credentials at definition time.
+*
+* Every `*Secret` field is a qualified `<context>:<secret-name>` reference into
+* the secrets backend — the same form `workflow()` enforces for
+* `registries[].tokenSecret`. Catching a pasted credential here matters because
+* the alternative is committing it to a git repository and discovering it later
+* as a confusing auth failure.
+*/
+/**
+* Validate a job's container registry auth at definition time.
+*
+* Same contract as `gitCredentials`: every `*Secret` field is a qualified
+* `<context>:<secret-name>` reference, and a pasted credential is refused
+* rather than committed to a git repository. The `*Value` half is material
+* supplied at run time and is deliberately not checked for shape.
+*/
+/**
+* Is `p` a repo-relative path that stays inside the repository?
+*
+* Rejects an absolute path and any path whose `..` segments walk out of the
+* tree. Deliberately string-only: the workflow is authored on one machine and
+* the path is resolved on another, so there is no filesystem here to consult.
+*/
+function isInsideRepo(p) {
+	if (p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)) return false;
+	let depth = 0;
+	for (const part of p.split(/[\\/]+/)) {
+		if (part === "" || part === ".") continue;
+		if (part === "..") {
+			depth -= 1;
+			if (depth < 0) return false;
+			continue;
+		}
+		depth += 1;
+	}
+	return true;
+}
+/**
+* A container names exactly one image source: a finalized `image`, or a
+* `dockerfile` the agent builds before the job runs.
+*
+* Refused at definition time rather than at dispatch, because the author is the
+* only one who can fix it and the workflow file is where they are looking. The
+* agent re-checks the paths against the real workdir — a lock file is repo
+* content and is not trusted — but that failure reaches a run log, not an
+* editor.
+*/
+function validateContainerImageSource(name, container) {
+	if (typeof container === "string") return;
+	const hasImage = typeof container.image === "string" && container.image.length > 0;
+	const hasDockerfile = typeof container.dockerfile === "string" && container.dockerfile.length > 0;
+	if (hasImage === hasDockerfile) throw new Error(`job('${name}'): exactly one of container.image or container.dockerfile is required`);
+	if (!hasDockerfile) {
+		for (const field of [
+			"context",
+			"target",
+			"args"
+		]) if (container[field] !== void 0) throw new Error(`job('${name}'): container.${field} applies only to container.dockerfile`);
+		return;
+	}
+	if (!isInsideRepo(container.dockerfile)) throw new Error(`job('${name}'): container.dockerfile must stay inside the repository (got: ${container.dockerfile})`);
+	if (container.context !== void 0 && !isInsideRepo(container.context)) throw new Error(`job('${name}'): container.context must stay inside the repository (got: ${container.context})`);
+	if (container.auth && typeof container.auth.registry !== "string") throw new Error(`job('${name}'): container.auth.registry is required with container.dockerfile — the base image is named inside the Dockerfile, so the registry cannot be derived`);
+}
+function validateContainerAuth(name, auth) {
+	const bag = auth;
+	for (const [field, value] of Object.entries(bag)) {
+		if (!field.endsWith("Secret") || typeof value !== "string") continue;
+		assertSecretName(value, field, "container registry credential");
+		const idx = value.indexOf(":");
+		if (idx <= 0 || idx >= value.length - 1 || value.slice(idx + 1).includes(":")) throw new Error(`job('${name}'): container.auth.${field} must use qualified <context>:<secret-name> syntax (got: ${value})`);
+	}
+}
+function validateGitCredentials(name, credentials) {
+	for (const [alias, ref] of Object.entries(credentials)) {
+		const bag = ref;
+		for (const [field, value] of Object.entries(bag)) {
+			if (!field.endsWith("Secret") || typeof value !== "string") continue;
+			assertSecretName(value, `${alias}.${field}`);
+			const idx = value.indexOf(":");
+			if (idx <= 0 || idx >= value.length - 1 || value.slice(idx + 1).includes(":")) throw new Error(`job('${name}'): gitCredentials.${alias}.${field} must use qualified <context>:<secret-name> syntax (got: ${value})`);
+		}
+	}
+}
 //#endregion
 export { job };
 

package/dist/needs-context.d.ts

@@ -14,6 +14,23 @@ export interface UpstreamSnapshot {
     jobs: Record<string, Record<string, unknown>>;
     groups: Record<string, string[]>;
     statuses?: Record<string, ExecutionJobStatus>;
+    /**
+     * Maps an invoke-gate job name to its ordered per-run results, one entry per
+     * run the gate triggered. Present only when the upstream is an invoke gate.
+     */
+    invokeResults?: Record<string, InvokeResult[]>;
+}
+/**
+ * One invoked-run result exposed on an invoke-gate upstream's
+ * `ctx.needs[gate].result` array — one entry per run the gate triggered.
+ * `outputs` carries the invoked run's non-secret declared outputs.
+ */
+export interface InvokeResult {
+    readonly repo: string;
+    readonly workflow: string;
+    readonly runId: string;
+    readonly status: string;
+    readonly outputs: Readonly<Record<string, unknown>>;
 }
 /**
  * A single-job need entry: the upstream's outputs proxy plus its terminal
@@ -31,8 +48,20 @@ export interface GroupNeedEntry<T = Record<string, unknown>> {
     result: OutputProxy<T>;
     status: ExecutionJobStatus;
 }
-/** A single-job need exposes `{ result, status }`; a group need exposes an ordered array. */
-export type NeedEntry<T = Record<string, unknown>> = SingleNeedEntry<T> | GroupNeedEntry[];
+/**
+ * An invoke-gate need entry: `ctx.needs['<gate>'].result` is an ordered array of
+ * {@link InvokeResult}, one per run the gate triggered.
+ */
+export interface InvokeNeedEntry {
+    result: readonly InvokeResult[];
+}
+/**
+ * A single-job need exposes `{ result, status }`; a group need exposes an
+ * ordered array of `{ name, result, status }`; an invoke-gate need exposes
+ * `{ result }` — an ordered array of {@link InvokeResult} on `.result`, one per
+ * triggered run.
+ */
+export type NeedEntry<T = Record<string, unknown>> = SingleNeedEntry<T> | GroupNeedEntry[] | InvokeNeedEntry;
 /** The resolved `ctx.needs` map keyed by job name or group name. */
 export type NeedsContext = Record<string, NeedEntry>;
 /**

package/dist/needs-context.js

@@ -34,7 +34,9 @@ function buildNeedsContext(snapshot, declaredNeeds) {
 	const out = {};
 	for (const need of declaredNeeds) {
 		const { kind, key } = needKey(need);
-		if (kind === "group") out[key] = (snapshot.groups[key] ?? []).map((name) => ({
+		const invokeResults = snapshot.invokeResults?.[key];
+		if (kind === "job" && invokeResults !== void 0) out[key] = { result: invokeResults };
+		else if (kind === "group") out[key] = (snapshot.groups[key] ?? []).map((name) => ({
 			name,
 			result: createSnapshotOutputProxy(name, snapshot.jobs[name]),
 			status: statusFor(snapshot, name)

package/dist/testing/step-context.js

@@ -218,13 +218,15 @@ function createTestStepContext(options = {}) {
 				get: () => Promise.resolve(null)
 			},
 			oidc: { token: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.oidc.token() is not available in a test step context")) },
+			git: { github: { getToken: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.git.github.getToken() is not available in a test step context")) } },
 			host: { requestReboot: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.host.requestReboot() is not available in a test step context")) },
 			bootstrap: {
 				ensureInitRunner: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.ensureInitRunner() is not available in a test step context")),
 				preBootSend: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.preBootSend() is not available in a test step context")),
 				agentVersionStatus: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.agentVersionStatus() is not available in a test step context")),
 				restageAgent: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.bootstrap.restageAgent() is not available in a test step context"))
-			}
+			},
+			scaler: { claimAgentCredentials: () => Promise.reject(/* @__PURE__ */ new Error("ctx.kici.scaler.claimAgentCredentials() is not available in a test step context")) }
 		},
 		cache: {
 			restore: async () => ({ hit: false }),

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { z } from 'zod';
 import type { $ as Shell } from 'zx';
 import type { RetryBackoff } from '@kici-dev/core';
+import type { GitCredentialMap, ContainerRegistryAuth } from './git-types.js';
 import type { ResourceRequest, RunsOnAllInput, OnUnreachableMode, NeedsWhen, ExecutionJobStatus } from '@kici-dev/engine';
 import type { StepContext, Logger, RepoInfo } from './context.js';
 import type { FilterFn } from './filter.js';
@@ -406,10 +407,43 @@ export { DYNAMIC_JOB_NEEDS_TAG };
  * When set, all steps run inside the specified container.
  */
 export interface ContainerConfig {
-    /** Docker image name (e.g., 'node:20-alpine') */
-    image: string;
+    /**
+     * Docker image name (e.g., 'node:20-alpine'). Mutually exclusive with
+     * `dockerfile`; exactly one of the two is required.
+     */
+    image?: string;
+    /**
+     * Repo-relative path to a Dockerfile the agent builds before the job runs.
+     * Mutually exclusive with `image`.
+     *
+     * The build runs on the agent host, NOT inside the job's hardened sandbox.
+     * See the container-jobs documentation for the trust model and the
+     * untrusted-ref rule.
+     */
+    dockerfile?: string;
+    /**
+     * Repo-relative build context. Defaults to the repository root.
+     * Meaningful only with `dockerfile`.
+     */
+    context?: string;
+    /** Build stage to stop at (`--target`). Meaningful only with `dockerfile`. */
+    target?: string;
+    /**
+     * Build arguments. Meaningful only with `dockerfile`.
+     *
+     * Plain strings only, deliberately: a build argument is recorded in the
+     * image's history, so a secret placed here is readable by anyone who can
+     * inspect the image. Pass a secret to a step instead.
+     */
+    args?: Record<string, string>;
     /** Additional environment variables for the container */
     env?: Record<string, string>;
+    /**
+     * Private-registry credentials. With `image` they pull that image; with
+     * `dockerfile` they pull the Dockerfile's own `FROM` base — and must name
+     * the registry, because there is no image reference to derive it from.
+     */
+    auth?: ContainerRegistryAuth;
 }
 /**
  * Per-job sandbox escape hatch for container-sandbox jobs (a job with a
@@ -574,6 +608,13 @@ export interface Job<TOutputs = Record<string, unknown>, TName extends string =
     readonly maxParallel?: number;
     /** Halt the fan-out on first child failure, skipping the remainder. Default `false`. */
     readonly failFast?: boolean;
+    /**
+     * Invoke the source repo's opt-in workflows and gate on them. Mutually
+     * exclusive with `steps` / `run` — an invoke job never runs step code on an
+     * agent; it fans out into one proxy node per triggered run. Built by
+     * `invokeSource()`.
+     */
+    readonly invoke?: import('./invoke.js').InvokeConfig;
     readonly steps: readonly StepInput[];
     readonly needs?: ReadonlyArray<Job | string | DynamicGroupRef | {
         name: string;
@@ -594,6 +635,17 @@ export interface Job<TOutputs = Record<string, unknown>, TName extends string =
     readonly exclude?: MatrixExclude[];
     /** When false, agent skips git clone (default: true). Useful for deploy/notify jobs. */
     readonly checkout?: boolean;
+    /**
+     * Named git credentials available to every step in this job.
+     *
+     * Values are **secret names**, resolved from the secrets backend — never
+     * secret material. `default` is used whenever a call names no credential;
+     * any other key is referenced by name, e.g.
+     * `kici.git.clone({ repo, credential: 'forge' })`.
+     *
+     * Omit entirely and the source credential applies, which is all a read needs.
+     */
+    readonly gitCredentials?: GitCredentialMap;
     /** Docker image for job execution. All steps run inside the container. */
     readonly container?: string | ContainerConfig;
     /** Per-job sandbox escape hatch (container jobs only); granted within the operator allow-list. */
@@ -709,6 +761,13 @@ export interface JobOptions {
      * of sibling outcomes). Applies to both matrix and `runsOnAll` fan-out.
      */
     failFast?: boolean;
+    /**
+     * Invoke the source repo's opt-in workflows and gate on them. Mutually
+     * exclusive with `steps` / `run` — an invoke job never runs step code on an
+     * agent; it fans out into one proxy node per triggered run. Built by
+     * `invokeSource()`.
+     */
+    invoke?: import('./invoke.js').InvokeConfig;
     /**
      * Steps to execute in this job. Accepts Step objects and bare async functions.
      * Mutually exclusive with `run`.
@@ -749,6 +808,17 @@ export interface JobOptions {
     exclude?: MatrixExclude[];
     /** When false, agent skips git clone (default: true). Useful for deploy/notify jobs. */
     checkout?: boolean;
+    /**
+     * Named git credentials available to every step in this job.
+     *
+     * Values are **secret names**, resolved from the secrets backend — never
+     * secret material. `default` is used whenever a call names no credential;
+     * any other key is referenced by name, e.g.
+     * `kici.git.clone({ repo, credential: 'forge' })`.
+     *
+     * Omit entirely and the source credential applies, which is all a read needs.
+     */
+    gitCredentials?: GitCredentialMap;
     /**
      * Docker image for job execution.
      * Simple string form for image name, object form for additional config.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kici-dev/sdk",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "TypeScript SDK for defining KiCI workflows. Import into `.kici/workflows/*.ts` to declare workflows, jobs, steps, triggers, rules, and matrix configurations.",
   "keywords": [
     "ci",
@@ -52,10 +52,11 @@
   },
   "dependencies": {
     "micromatch": "^4.0.8",
+    "yaml": "^2.9.0",
     "zod": "^4.4.3",
     "zx": "^8.8.5",
-    "@kici-dev/core": "0.5.0",
-    "@kici-dev/engine": "0.5.0"
+    "@kici-dev/core": "0.6.1",
+    "@kici-dev/engine": "0.6.1"
   },
   "devDependencies": {
     "@types/micromatch": "^4.0.10"