@kici-dev/compiler 0.6.0 → 0.7.0

package/dist/llm-context/llms.txt

@@ -4,19 +4,22 @@
 
 The full markdown bundle of every page indexed here is available at https://docs.kici.dev/llms-full.txt.
 
+Found a mismatch between what these docs advertise and what KiCI does? Read https://docs.kici.dev/user/reporting-discrepancies/ (or run `kici feedback`) before reporting it: a report needs a reproduction, and you draft it but a human decides to file it.
+
 ## Bundles
 
 Each bundle below is a self-contained markdown file for one authoring task. Fetch only the one your task needs instead of the full bundle:
 
-- [getting-started](https://docs.kici.dev/llms-getting-started.txt) (58 KB) — Adopt KiCI: why it exists, how workflows execute, migrating from GitHub Actions, installing the SDK, and writing/compiling/testing your first workflow
-- [patterns](https://docs.kici.dev/llms-patterns.txt) (57 KB) — Copy-paste workflow recipes: triggers, conditionals, matrix, scheduling, integrations
-- [sdk](https://docs.kici.dev/llms-sdk.txt) (127 KB) — Core authoring API: workflow/job/step factories, triggers, rules, matrix, dynamic jobs, cross-job outputs
-- [sdk-runtime](https://docs.kici.dev/llms-sdk-runtime.txt) (114 KB) — Runtime and advanced authoring: step runtime context, event payloads, host fan-out, idempotent steps, caching, artifacts, waiting
-- [cli](https://docs.kici.dev/llms-cli.txt) (194 KB) — Running the CLI: compile, test, run local/remote, auth, hooks, lock-file drift
-- [features](https://docs.kici.dev/llms-features.txt) (90 KB) — Deployment contexts, scoped secrets, private registries, approvals, provenance, dashboard and account access
-- [features-execution](https://docs.kici.dev/llms-features-execution.txt) (120 KB) — Concurrency, dynamic values, events, container jobs, environment variables, global workflows, idempotent steps
+- [getting-started](https://docs.kici.dev/llms-getting-started.txt) (65 KB) — Adopt KiCI: why it exists, how workflows execute, migrating from GitHub Actions, installing the SDK, and writing/compiling/testing your first workflow
+- [patterns](https://docs.kici.dev/llms-patterns.txt) (61 KB) — Copy-paste workflow recipes: triggers, conditionals, matrix, scheduling, integrations
+- [sdk](https://docs.kici.dev/llms-sdk.txt) (131 KB) — Core authoring API: workflow/job/step factories, triggers, rules, matrix, dynamic jobs, cross-job outputs
+- [sdk-runtime](https://docs.kici.dev/llms-sdk-runtime.txt) (115 KB) — Runtime and advanced authoring: step runtime context, event payloads, host fan-out, idempotent steps, caching, artifacts, waiting
+- [cli](https://docs.kici.dev/llms-cli.txt) (97 KB) — Running the CLI locally: compile, test, run local, hooks, lock-file drift, common failures
+- [cli-remote](https://docs.kici.dev/llms-cli-remote.txt) (109 KB) — Auth, org and orchestrator selection, runs, approvals, notifications, diagnostics, and the MCP server a coding agent connects to
+- [features](https://docs.kici.dev/llms-features.txt) (97 KB) — Deployment contexts, scoped secrets, private registries, approvals, provenance, dashboard and account access
+- [features-execution](https://docs.kici.dev/llms-features-execution.txt) (124 KB) — Concurrency, dynamic values, events, container jobs, environment variables, global workflows, idempotent steps
 - [providers](https://docs.kici.dev/llms-providers.txt) (35 KB) — Connecting sources: GitHub App, universal-git (Forgejo/Gitea/GitLab), local file://
-- [architecture](https://docs.kici.dev/llms-architecture.txt) (99 KB) — How the runtime works: three-tier relay model, data flows, configuration
+- [architecture](https://docs.kici.dev/llms-architecture.txt) (100 KB) — How the runtime works: three-tier relay model, data flows, configuration
 
 ## Getting started
 
@@ -26,6 +29,7 @@ Each bundle below is a self-contained markdown file for one authoring task. Fetc
 - [Getting started with workflows](https://docs.kici.dev/user/getting-started/): Install the SDK, write your first workflow, compile and test locally
 - [Migrating from GitHub Actions](https://docs.kici.dev/user/migrating-from-github-actions/): Map GitHub Actions concepts to KiCI, translate a real workflow side-by-side, and see what has no equivalent yet
 - [5-minute quickstart](https://docs.kici.dev/user/quickstart/): Stand up a KiCI orchestrator + agent and run your first workflow
+- [Reporting a discrepancy](https://docs.kici.dev/user/reporting-discrepancies/): For coding agents — how to report a mismatch between what KiCI's docs advertise and what the tooling does, with the reproduction and the approval a report needs.
 - [Why KiCI](https://docs.kici.dev/user/why-kici/): The case for running CI on infrastructure you control, with typed TypeScript workflows you test locally
 
 ## Workflow patterns
@@ -58,18 +62,21 @@ Each bundle below is a self-contained markdown file for one authoring task. Fetc
 - [SDK reference: temp directories](https://docs.kici.dev/user/sdk/temp-directories/): Allocate job-scoped scratch dirs and files with ctx.mktemp() / ctx.mktempFile()
 - [SDK reference: waitFor](https://docs.kici.dev/user/sdk/wait-for/): Polling helpers for steps that pause until an external condition becomes true
 
-## CLI and authoring
+## CLI: authoring on your own machine
 
-- [Drive KiCI from your coding agent](https://docs.kici.dev/user/ai-agents/): Point a coding agent at KiCI's MCP server and let it trigger, read, and re-run your CI under your own identity.
-- [CLI authentication](https://docs.kici.dev/user/cli-auth/): Authenticate the KiCI CLI with browser OAuth, device flow, or API key paste
-- [CLI reference](https://docs.kici.dev/user/cli-reference/): All CLI commands: compile, preview, local, fixture, types, workflows, hook, docs, run, runs, approve, reject, login, logout, init, org, pat, secrets, admin, orchestrators, endpoints, notifications, verify-attestation, diagnostics, doctor, report
+- [CLI reference](https://docs.kici.dev/user/cli-reference/): All CLI commands: compile, preview, local, fixture, types, workflows, hook, docs, run, runs, approve, reject, login, logout, init, org, pat, secrets, admin, orchestrators, endpoints, notifications, verify-attestation, diagnostics, doctor, report, feedback
 - [Common failures](https://docs.kici.dev/user/common-failures/): Symptom-to-fix reference for the failures workflow authors hit most — no jobs dispatched, lock-file drift, missing webhooks, and agents that won't connect
 - [Lifecycle hooks](https://docs.kici.dev/user/hooks/): SDK hook API for cancel, cleanup, success, failure, and step-level callbacks
 - [Lock file and workflow drift](https://docs.kici.dev/user/lock-file-and-drift/): Keep the lock file in sync with your workflow source and avoid drift
 - [Testing guide](https://docs.kici.dev/user/testing-guide/): Running remote test fixtures with kici run remote
 - [Workflow patterns](https://docs.kici.dev/user/workflow-patterns/): Common patterns: monorepo builds, conditional jobs, dynamic matrices, generic webhooks, scheduling
-- [kici: account & org](https://docs.kici.dev/user/cli/account-and-org/): Login, org selection, personal access tokens, secrets, and admin
 - [kici: authoring & local dev](https://docs.kici.dev/user/cli/authoring-and-local/): Compile, preview, local execution, fixtures, types, workflows, hooks, and docs
+
+## CLI: driving a deployed orchestrator
+
+- [Drive KiCI from your coding agent](https://docs.kici.dev/user/ai-agents/): Point a coding agent at KiCI's MCP server and let it trigger, read, and re-run your CI under your own identity.
+- [CLI authentication](https://docs.kici.dev/user/cli-auth/): Authenticate the KiCI CLI with browser OAuth, device flow, or API key paste
+- [kici: account & org](https://docs.kici.dev/user/cli/account-and-org/): Login, org selection, personal access tokens, secrets, and admin
 - [kici: notifications & diagnostics](https://docs.kici.dev/user/cli/notifications-and-diagnostics/): Notification channels, attestation verification, and diagnostics
 - [kici: runs & approvals](https://docs.kici.dev/user/cli/runs-and-approvals/): Run push and inspection plus approval / rejection of held runs
 

package/dist/local-plane/orchestrator-process.d.ts

@@ -1,11 +1,3 @@
-/**
- * Resolve a host address the plane's co-located bare-metal agent can reach for
- * cache-blob fetches. The orchestrator refuses to hand a scaler a loopback
- * storage URL (it assumes remote agents), so the plane advertises its first
- * non-internal IPv4 (still this machine — the agent is co-located). Falls back
- * to the hostname when no external interface is present.
- */
-export declare function resolveAgentReachableHost(): string;
 /**
  * Resolve the built `@kici-dev/orchestrator/standalone` entry the local plane
  * launches in independent (offline) mode.

package/dist/local-plane/orchestrator-process.js

@@ -3,20 +3,8 @@ import { planePaths, planePorts } from "./paths.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import { spawn } from "node:child_process";
-import os from "node:os";
 //#region src/local-plane/orchestrator-process.ts
 /**
-* Resolve a host address the plane's co-located bare-metal agent can reach for
-* cache-blob fetches. The orchestrator refuses to hand a scaler a loopback
-* storage URL (it assumes remote agents), so the plane advertises its first
-* non-internal IPv4 (still this machine — the agent is co-located). Falls back
-* to the hostname when no external interface is present.
-*/
-function resolveAgentReachableHost() {
-	for (const addrs of Object.values(os.networkInterfaces())) for (const a of addrs ?? []) if (a.family === "IPv4" && !a.internal) return a.address;
-	return os.hostname();
-}
-/**
 * Resolve the built `@kici-dev/orchestrator/standalone` entry the local plane
 * launches in independent (offline) mode.
 */
@@ -68,6 +56,7 @@ function spawnOrchestratorProcess(databaseUrl, opts) {
 		KICI_PORT: String(port),
 		KICI_DATABASE_URL: databaseUrl,
 		KICI_AGENT_AUTH: "none",
+		KICI_HOST: "127.0.0.1",
 		KICI_AUTO_MIGRATE: "true",
 		KICI_DATA_DIR: root,
 		KICI_BOOTSTRAP_ADMIN_TOKEN: opts.adminToken,
@@ -76,7 +65,7 @@ function spawnOrchestratorProcess(databaseUrl, opts) {
 		KICI_WEBHOOK_PUBLIC_URL: `http://127.0.0.1:${port}`,
 		KICI_STORAGE_TYPE: "filesystem",
 		KICI_STORAGE_FS_PATH: cacheDir,
-		KICI_STORAGE_FS_BASE_URL: `http://${resolveAgentReachableHost()}:${port}`
+		KICI_STORAGE_FS_BASE_URL: `http://127.0.0.1:${port}`
 	};
 	let entry;
 	let modeEnv;
@@ -124,6 +113,6 @@ async function awaitOrchestratorReady(port, attempts = 120, intervalMs = 500) {
 	throw new Error("local orchestrator did not become ready");
 }
 //#endregion
-export { awaitOrchestratorReady, orchestratorReady, resolveAgentReachableHost, resolveServerEntry, resolveStandaloneEntry, spawnOrchestratorProcess };
+export { awaitOrchestratorReady, orchestratorReady, resolveServerEntry, resolveStandaloneEntry, spawnOrchestratorProcess };
 
 //# sourceMappingURL=orchestrator-process.js.map

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

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

package/dist/lockfile/generator.js

@@ -2,18 +2,20 @@ import "../rolldown-runtime-ClRpJifh.js";
 import { compilerError } from "../errors/formatter.js";
 import { locationForJob, locationForWorkflow } from "../errors/source-location.js";
 import "../errors/index.js";
+import { computeSiblingsDigest } from "./workspace-siblings.js";
 import { BREAKING_FLOOR as BREAKING_FLOOR$1, SCHEMA_VERSION as SCHEMA_VERSION$1 } from "../types.js";
-import { computeContentHash } from "./hasher.js";
+import { COMPILE_SCHEMA_VERSION, computeContentHash } from "./hasher.js";
 import { resolveHashFiles } from "./hash-files.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 { getDynamicJobGitCredentials, getDynamicJobGroup, getDynamicJobNeeds, isDynamicFunction, isDynamicGroupRef, isDynamicJobFn, isParallelGroup, isStaticArray, isStaticObject } from "@kici-dev/sdk";
 import { sha256 } from "@kici-dev/core";
 import { PackageManager, detectPackageManagerSync, detectYarnFlavorSync } from "@kici-dev/core/package-manager";
-import { assertScheduleInputsSatisfiable, extractInputsDescriptorMap, resolveContentFormat, resolveWhenToRunOn, validateResourceRequest } from "@kici-dev/engine";
+import { assertScheduleInputsSatisfiable, extractInputsDescriptorMap, resolveContentFormat, resolveWhenToRunOn, stripStatefulRegexFlags, 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";
+import { normalizeRunsOnAllToMatchers, normalizeRunsOnToMatchers, runsOnPickFromInput } from "@kici-dev/engine/labels/compile";
+import { normalizeApproval, normalizeCacheSpecs } from "@kici-dev/sdk/internal";
 //#region src/lockfile/generator.ts
 /**
 * Courtesy compatibility warning for `kici compile`.
@@ -124,6 +126,7 @@ function formatExportRef(source) {
 function generateLockFile(workflowsWithSource) {
 	const gitRoot = detectGitRoot();
 	const lockfileHash = computeLockfileHash(gitRoot);
+	const siblingsDigest = computeSiblingsDigest(gitRoot);
 	const firstSource = workflowsWithSource[0]?.source;
 	const topLevelSource = firstSource ? {
 		file: path.relative(gitRoot, firstSource.file).replaceAll("\\", "/"),
@@ -147,6 +150,7 @@ function generateLockFile(workflowsWithSource) {
 		source: topLevelSource,
 		contentHash,
 		...lockfileHash && { lockfileHash },
+		...siblingsDigest && { siblingsDigest },
 		workflows
 	};
 }
@@ -169,8 +173,8 @@ function transformWorkflow(workflow, sourceFile, exportRef, bundleSource, gitRoo
 			resolvedHashFiles = resolved.resolvedPaths;
 		}
 	}
-	const contentHash = bundleSource !== void 0 ? computeContentHash(bundleSource, 5, assetDigest) : "";
-	const compileSchemaVersion = bundleSource !== void 0 ? 5 : 0;
+	const contentHash = bundleSource !== void 0 ? computeContentHash(bundleSource, COMPILE_SCHEMA_VERSION, assetDigest) : "";
+	const compileSchemaVersion = bundleSource !== void 0 ? COMPILE_SCHEMA_VERSION : 0;
 	return {
 		name: workflow.name,
 		source: {
@@ -220,15 +224,25 @@ function toArray(v) {
 	return Array.isArray(v) ? v : [v];
 }
 /**
+* The `/pattern/flags` shape the lock file stores.
+*
+* The flag class must name every ECMAScript flag, not just the ones that
+* predate ES2022. When it read `[gimsuy]`, a `d`- or `v`-flagged regex failed
+* to unwrap, so `pattern` became the whole `/release-\d+/v` string — which
+* `new RegExp` happily accepts as a pattern matching literal slashes. The lock
+* then stored `/\/release-\d+\/v/`, which compiles green and can never match.
+*/
+const REGEX_ENTRY = /^\/(.+)\/([dgimsuvy]*)$/;
+/**
 * 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 wrapped = REGEX_ENTRY.exec(source);
 	const pattern = wrapped ? wrapped[1] : source;
-	const flags = wrapped ? wrapped[2] : "";
+	const flags = stripStatefulRegexFlags(wrapped ? wrapped[2] : "");
 	let re;
 	try {
 		re = new RegExp(pattern, flags);
@@ -605,6 +619,7 @@ function transformJobs(jobs, configPath, gitRoot) {
 		if (isDynamicJobFn(jobOrFactory)) {
 			const groupName = getDynamicJobGroup(jobOrFactory);
 			const declaredNeeds = getDynamicJobNeeds(jobOrFactory);
+			const declaredGitCredentials = getDynamicJobGitCredentials(jobOrFactory);
 			const resolvedNeeds = declaredNeeds ? resolveNeedsForLock(declaredNeeds, uuidToName) : void 0;
 			return {
 				_type: "dynamic",
@@ -616,7 +631,8 @@ function transformJobs(jobs, configPath, gitRoot) {
 				...resolvedNeeds && {
 					needs: resolvedNeeds.needs,
 					resultAware: true
-				}
+				},
+				...declaredGitCredentials && { gitCredentials: declaredGitCredentials }
 			};
 		}
 		const j = jobOrFactory;

package/dist/lockfile/hasher.d.ts

@@ -1,18 +1,10 @@
 /**
- * Compile schema version -- bump when compilation approach changes
- * (bundler change, bundling config, output format, etc.).
- * This is NOT the lock file schema version.
- *
- * Bumped 3 → 4: the agent artifact switched from a Rolldown-bundled
- * `.compiled.mjs` to a raw `.kici/` source tarball that the agent extracts
- * and imports via the shared oxc-transform ESM loader hook.
- *
- * Bumped 4 → 5: the hash input is now line-ending-normalized (CRLF → LF) so a
- * lockfile produced on Linux (LF) matches the agent's hash on Windows, where
- * Git's `core.autocrlf=true` system default rewrites checked-out text files to
- * CRLF. Old lockfiles must be regenerated via `kici compile`.
+ * Compile schema version, re-exported from its single definition in
+ * `@kici-dev/core/kici-source-digest` — where it sits beside the digest it
+ * qualifies, so the compiler that writes a `contentHash` and the agent that
+ * re-verifies it cannot drift onto different numbers.
  */
-export declare const COMPILE_SCHEMA_VERSION = 5;
+export { COMPILE_SCHEMA_VERSION } from '@kici-dev/core/kici-source-digest';
 /**
  * Compute content hash for a compiled workflow bundle, optionally including asset file contents.
  * Hash = SHA-256(schemaVersion + ":" + bundleSource + "\0" + assetDigest) when assetDigest is provided,

package/dist/lockfile/hasher.js

@@ -1,22 +1,8 @@
 import "../rolldown-runtime-ClRpJifh.js";
+import { COMPILE_SCHEMA_VERSION } from "@kici-dev/core/kici-source-digest";
 import { normalizeLineEndings, sha256 } from "@kici-dev/core";
 //#region src/lockfile/hasher.ts
 /**
-* Compile schema version -- bump when compilation approach changes
-* (bundler change, bundling config, output format, etc.).
-* This is NOT the lock file schema version.
-*
-* Bumped 3 → 4: the agent artifact switched from a Rolldown-bundled
-* `.compiled.mjs` to a raw `.kici/` source tarball that the agent extracts
-* and imports via the shared oxc-transform ESM loader hook.
-*
-* Bumped 4 → 5: the hash input is now line-ending-normalized (CRLF → LF) so a
-* lockfile produced on Linux (LF) matches the agent's hash on Windows, where
-* Git's `core.autocrlf=true` system default rewrites checked-out text files to
-* CRLF. Old lockfiles must be regenerated via `kici compile`.
-*/
-const COMPILE_SCHEMA_VERSION = 5;
-/**
 * Compute content hash for a compiled workflow bundle, optionally including asset file contents.
 * Hash = SHA-256(schemaVersion + ":" + bundleSource + "\0" + assetDigest) when assetDigest is provided,
 * otherwise SHA-256(schemaVersion + ":" + bundleSource) for backward compatibility.

package/dist/lockfile/workspace-siblings.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Static resolution of the in-repo `workspace:` sibling closure `.kici` depends
+ * on, and a digest over its source.
+ *
+ * The deps tarball carries those sibling package directories **with their built
+ * output** (`packKiciDeps`), while the pointer that names it is keyed on
+ * `lockfileHash` — a hash of the package-manager lock file. Editing a sibling's
+ * source moves no package-manager lock file, so a repo whose `.kici` depends on
+ * an in-repo `workspace:` package restored that sibling's STALE build over the
+ * fresh clone on every warm-cache run. `siblingsDigest` closes that: it enters
+ * the dep pointer key, so a sibling edit is a pointer miss and the deps are
+ * rebuilt.
+ *
+ * Resolution is **static** — manifests and `git ls-files`, never an installed
+ * `node_modules`. The agent's own `collectInRepoSiblings` walks an installed
+ * tree, which cannot be used here: `kici compile` would then emit a different
+ * lock file before and after an install, and a lock file whose contents depend
+ * on whether you have installed is not hermetic.
+ */
+/**
+ * The workspace globs declared at the repo root — `pnpm-workspace.yaml`'s
+ * `packages:` first, then `package.json#workspaces` (npm / yarn / bun). Empty
+ * when the repo declares no workspace, in which case a `workspace:` specifier
+ * resolves to nothing and is skipped rather than guessed at.
+ */
+export declare function readWorkspaceGlobs(gitRoot: string): string[];
+/**
+ * Every in-repo sibling directory `.kici` depends on, transitively, as sorted
+ * repo-relative POSIX paths.
+ *
+ * `.kici` itself is excluded: its own source is already covered by
+ * `contentHash`, and including it here would make a `.kici` edit invalidate the
+ * dep cache for no reason.
+ */
+export declare function collectInRepoSiblings(gitRoot: string, kiciDir?: string): string[];
+/**
+ * SHA-256 over the git-tracked source of every resolved sibling directory, or
+ * null when `.kici` depends on none.
+ *
+ * `git ls-files` is install-independent and is already the compiler's world (it
+ * resolves `gitRoot` to generate the lock at all). Content is read as text and
+ * `\0`-delimited against its path, exactly as the `.kici/` tree digest is, so a
+ * rename cannot be disguised as a content edit.
+ */
+export declare function computeSiblingsDigest(gitRoot: string, kiciDir?: string): string | null;
+//# sourceMappingURL=workspace-siblings.d.ts.map

package/dist/lockfile/workspace-siblings.js

@@ -0,0 +1,197 @@
+import "../rolldown-runtime-ClRpJifh.js";
+import path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { sha256 } from "@kici-dev/core";
+import { execFileSync } from "node:child_process";
+import { parse } from "yaml";
+//#region src/lockfile/workspace-siblings.ts
+/**
+* Static resolution of the in-repo `workspace:` sibling closure `.kici` depends
+* on, and a digest over its source.
+*
+* The deps tarball carries those sibling package directories **with their built
+* output** (`packKiciDeps`), while the pointer that names it is keyed on
+* `lockfileHash` — a hash of the package-manager lock file. Editing a sibling's
+* source moves no package-manager lock file, so a repo whose `.kici` depends on
+* an in-repo `workspace:` package restored that sibling's STALE build over the
+* fresh clone on every warm-cache run. `siblingsDigest` closes that: it enters
+* the dep pointer key, so a sibling edit is a pointer miss and the deps are
+* rebuilt.
+*
+* Resolution is **static** — manifests and `git ls-files`, never an installed
+* `node_modules`. The agent's own `collectInRepoSiblings` walks an installed
+* tree, which cannot be used here: `kici compile` would then emit a different
+* lock file before and after an install, and a lock file whose contents depend
+* on whether you have installed is not hermetic.
+*/
+/** Dependency protocols that name a directory inside this repository. */
+const IN_REPO_PROTOCOLS = [
+	"workspace:",
+	"file:",
+	"link:",
+	"portal:"
+];
+function readManifest(dir) {
+	const file = path.join(dir, "package.json");
+	if (!existsSync(file)) return null;
+	try {
+		return JSON.parse(readFileSync(file, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Every dependency specifier in a manifest, across all four dependency maps. */
+function allSpecifiers(m) {
+	return Object.entries({
+		...m.dependencies,
+		...m.devDependencies,
+		...m.optionalDependencies,
+		...m.peerDependencies
+	});
+}
+/**
+* The workspace globs declared at the repo root — `pnpm-workspace.yaml`'s
+* `packages:` first, then `package.json#workspaces` (npm / yarn / bun). Empty
+* when the repo declares no workspace, in which case a `workspace:` specifier
+* resolves to nothing and is skipped rather than guessed at.
+*/
+function readWorkspaceGlobs(gitRoot) {
+	const pnpmFile = path.join(gitRoot, "pnpm-workspace.yaml");
+	if (existsSync(pnpmFile)) try {
+		const doc = parse(readFileSync(pnpmFile, "utf-8"));
+		if (Array.isArray(doc?.packages)) return doc.packages.filter((p) => typeof p === "string");
+	} catch {}
+	const ws = readManifest(gitRoot)?.workspaces;
+	if (Array.isArray(ws)) return ws;
+	if (ws && Array.isArray(ws.packages)) return ws.packages;
+	return [];
+}
+/**
+* Directories the workspace globs match, each carrying a manifest. Resolved with
+* `git ls-files` so the set is exactly what is tracked — the same authority the
+* digest itself uses, and one that needs no install.
+*/
+function workspacePackageDirs(gitRoot, globs) {
+	const byName = /* @__PURE__ */ new Map();
+	if (globs.length === 0) return byName;
+	let manifests;
+	try {
+		manifests = execFileSync("git", [
+			"ls-files",
+			"--",
+			"*package.json",
+			"package.json"
+		], {
+			cwd: gitRoot,
+			encoding: "utf-8",
+			maxBuffer: 33554432
+		}).split("\n").filter(Boolean);
+	} catch {
+		return byName;
+	}
+	for (const rel of manifests) {
+		const dir = path.dirname(rel);
+		if (dir.split("/").includes("node_modules")) continue;
+		const m = readManifest(path.join(gitRoot, dir));
+		if (m?.name) byName.set(m.name, dir);
+	}
+	return byName;
+}
+/**
+* Resolve one specifier to a repo-relative directory, or null when it does not
+* name one. `file:` / `link:` / `portal:` carry the path; `workspace:` carries a
+* version range, so the package NAME is resolved through the workspace globs.
+*/
+function resolveSpecifier(pkgName, spec, fromDir, gitRoot, workspacePkgs) {
+	if (spec.startsWith("workspace:")) return workspacePkgs.get(pkgName) ?? null;
+	for (const proto of [
+		"file:",
+		"link:",
+		"portal:"
+	]) {
+		if (!spec.startsWith(proto)) continue;
+		const target = spec.slice(proto.length);
+		const abs = path.resolve(gitRoot, fromDir, target);
+		const rel = path.relative(gitRoot, abs).replaceAll("\\", "/");
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		return rel;
+	}
+	return null;
+}
+/**
+* Every in-repo sibling directory `.kici` depends on, transitively, as sorted
+* repo-relative POSIX paths.
+*
+* `.kici` itself is excluded: its own source is already covered by
+* `contentHash`, and including it here would make a `.kici` edit invalidate the
+* dep cache for no reason.
+*/
+function collectInRepoSiblings(gitRoot, kiciDir = ".kici") {
+	const kiciManifest = readManifest(path.join(gitRoot, kiciDir));
+	if (!kiciManifest) return [];
+	const workspacePkgs = workspacePackageDirs(gitRoot, readWorkspaceGlobs(gitRoot));
+	const found = /* @__PURE__ */ new Set();
+	const queue = [{
+		dir: kiciDir,
+		manifest: kiciManifest
+	}];
+	const visited = /* @__PURE__ */ new Set([kiciDir]);
+	while (queue.length > 0) {
+		const { dir, manifest } = queue.shift();
+		for (const [name, spec] of allSpecifiers(manifest)) {
+			if (!IN_REPO_PROTOCOLS.some((p) => spec.startsWith(p))) continue;
+			const target = resolveSpecifier(name, spec, dir, gitRoot, workspacePkgs);
+			if (target === null || visited.has(target)) continue;
+			visited.add(target);
+			found.add(target);
+			const m = readManifest(path.join(gitRoot, target));
+			if (m) queue.push({
+				dir: target,
+				manifest: m
+			});
+		}
+	}
+	return [...found].sort();
+}
+/**
+* SHA-256 over the git-tracked source of every resolved sibling directory, or
+* null when `.kici` depends on none.
+*
+* `git ls-files` is install-independent and is already the compiler's world (it
+* resolves `gitRoot` to generate the lock at all). Content is read as text and
+* `\0`-delimited against its path, exactly as the `.kici/` tree digest is, so a
+* rename cannot be disguised as a content edit.
+*/
+function computeSiblingsDigest(gitRoot, kiciDir = ".kici") {
+	const siblings = collectInRepoSiblings(gitRoot, kiciDir);
+	if (siblings.length === 0) return null;
+	const parts = [];
+	for (const dir of siblings) {
+		let files;
+		try {
+			files = execFileSync("git", [
+				"ls-files",
+				"--",
+				dir
+			], {
+				cwd: gitRoot,
+				encoding: "utf-8",
+				maxBuffer: 67108864
+			}).split("\n").filter(Boolean).sort();
+		} catch {
+			continue;
+		}
+		for (const rel of files) {
+			let content = "";
+			try {
+				content = readFileSync(path.join(gitRoot, rel), "utf-8");
+			} catch {}
+			parts.push(`${rel}\0${content.replaceAll("\r\n", "\n")}\0`);
+		}
+	}
+	return parts.length > 0 ? sha256(parts.join("")) : null;
+}
+//#endregion
+export { collectInRepoSiblings, computeSiblingsDigest, readWorkspaceGlobs };
+
+//# sourceMappingURL=workspace-siblings.js.map

package/dist/templates/package-json.js

@@ -1,6 +1,6 @@
 import "../rolldown-runtime-ClRpJifh.js";
 //#region src/templates/package-json.ts
-const sdkVersion = "0.6.0";
+const sdkVersion = "0.7.0";
 /**
 * The npm version range the scaffold pins `@kici-dev/sdk` to.
 *

package/dist/test-runner/job-executor.js

@@ -6,8 +6,8 @@ import { localRunsOnString } from "./runs-on-display.js";
 import { pathToFileURL } from "node:url";
 import path from "node:path";
 import pc from "picocolors";
-import { setJobOutputsMap, setStepOutputsMap, setStepRefMap } from "@kici-dev/sdk";
 import { logger } from "@kici-dev/core";
+import { setJobOutputsMap, setStepOutputsMap, setStepRefMap } from "@kici-dev/sdk/internal";
 //#region src/test-runner/job-executor.ts
 /**
 * Resolve SDK output setter functions from the workflow's module instance.

package/dist/test-runner/rule-evaluator.js

@@ -1,7 +1,7 @@
 import "../rolldown-runtime-ClRpJifh.js";
 import { formatter } from "./output-formatter.js";
-import { createRuleContext as createRuleContext$1, evaluateRules } from "@kici-dev/sdk";
 import { initZx } from "@kici-dev/core";
+import { createRuleContext as createRuleContext$1, evaluateRules } from "@kici-dev/sdk/internal";
 //#region src/test-runner/rule-evaluator.ts
 initZx();
 /**

package/dist/types.d.ts

@@ -28,7 +28,7 @@ export interface LockApproval {
     readonly when: 'always' | 'drift';
 }
 /** Schema version - re-exported from engine as single source of truth */
-export declare const SCHEMA_VERSION: 39;
+export declare const SCHEMA_VERSION: 41;
 /** Lock compatibility-window floor - re-exported from engine as single source of truth */
 export declare const BREAKING_FLOOR: 30;
 /**
@@ -570,6 +570,11 @@ export interface LockDynamicJobFn {
     readonly needs?: readonly (string | LockNeedsEntry | LockNeedsGroupEntry)[];
     /** True when this dynamic entry was authored as dynamicJob(group, { needs, generate }). */
     readonly resultAware?: boolean;
+    /**
+     * Named git credentials the generator declares, inherited by every job it
+     * generates. Mirrors the engine `LockDynamicJobFn.gitCredentials`.
+     */
+    readonly gitCredentials?: Readonly<Record<string, Readonly<Record<string, string>>>>;
 }
 /** Job or dynamic job generator */
 export type LockJobOrFactory = LockJob | LockDynamicJobFn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kici-dev/compiler",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Compiler and CLI for KiCI workflows. Compiles `.kici/workflows/*.ts` to a `kici.lock.json` file consumed by the orchestrator and agents, and runs workflows locally or against a remote orchestrator.",
   "keywords": [
     "ci",
@@ -33,7 +33,6 @@
   "files": [
     "dist",
     "!dist/**/*.map",
-    "hack/postinstall.mjs",
     "sbom.spdx.json"
   ],
   "main": "dist/index.js",
@@ -62,24 +61,23 @@
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
     "zx": "^8.8.5",
-    "@kici-dev/agent": "0.6.0",
-    "@kici-dev/core": "0.6.0",
-    "@kici-dev/engine": "0.6.0",
-    "@kici-dev/orchestrator": "0.6.0"
+    "@kici-dev/agent": "0.7.0",
+    "@kici-dev/orchestrator": "0.7.0",
+    "@kici-dev/core": "0.7.0",
+    "@kici-dev/engine": "0.7.0"
   },
   "devDependencies": {
     "@types/archiver": "^8.0.0",
     "jszip": "^3.10.1"
   },
   "peerDependencies": {
-    "@kici-dev/sdk": "0.6.0"
+    "@kici-dev/sdk": "0.7.0"
   },
   "scripts": {
     "build": "node ../../scripts/build-ts.mjs && tsgo --emitDeclarationOnly",
     "postbuild": "zx hack/postbuild.mjs",
     "typecheck": "tsgo --noEmit",
     "test": "vitest run",
-    "test:watch": "vitest",
-    "postinstall": "node hack/postinstall.mjs"
+    "test:watch": "vitest"
   }
 }