@kilnai/cli 1.0.4 → 2.0.0

package/dist/application/project-root-resolver.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+export function resolveProjectRoot(options = {}) {
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const start = normalizeStartPath(resolve(cwd, options.explicitPath ?? "."));
+    const kilnRoot = findAncestor(start, (candidate) => existsSync(join(candidate, ".kiln", "kiln.yaml")));
+    if (kilnRoot) {
+        return {
+            rootPath: kilnRoot,
+            source: "kiln-yaml",
+            hasKilnYaml: true,
+            hasGitRoot: hasGitMarker(kilnRoot),
+            projectName: readProjectName(kilnRoot),
+        };
+    }
+    const gitRoot = findAncestor(start, hasGitMarker);
+    if (gitRoot) {
+        return {
+            rootPath: gitRoot,
+            source: "git",
+            hasKilnYaml: false,
+            hasGitRoot: true,
+            projectName: readProjectName(gitRoot),
+        };
+    }
+    return {
+        rootPath: start,
+        source: options.explicitPath ? "explicit" : "cwd",
+        hasKilnYaml: false,
+        hasGitRoot: false,
+        projectName: readProjectName(start),
+    };
+}
+function normalizeStartPath(path) {
+    if (!existsSync(path)) {
+        return path;
+    }
+    return statSync(path).isFile() ? dirname(path) : path;
+}
+function findAncestor(start, predicate) {
+    let current = start;
+    while (true) {
+        if (predicate(current)) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function hasGitMarker(candidate) {
+    return existsSync(join(candidate, ".git"));
+}
+function readProjectName(projectPath) {
+    const packageJsonPath = join(projectPath, "package.json");
+    if (existsSync(packageJsonPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+            if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
+                return parsed.name.trim();
+            }
+        }
+        catch {
+            return basename(projectPath);
+        }
+    }
+    return basename(projectPath);
+}
+//# sourceMappingURL=project-root-resolver.js.map

package/dist/application/project-root-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root-resolver.js","sourceRoot":"","sources":["../../src/application/project-root-resolver.ts"],"names":[],"mappings":"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"}

package/dist/application/repo-shim-projection.d.ts

@@ -0,0 +1,48 @@
+import { type WorkflowSnapshotExport } from "./workflow-snapshot-export.js";
+export type RepoShimKind = "agents" | "claude";
+export interface RepoShimProjectionTargetResult {
+    readonly kind: RepoShimKind;
+    readonly path: string;
+    readonly written: boolean;
+    readonly status: "written" | "blocked" | "unchanged";
+    readonly errors: readonly string[];
+}
+export interface RepoShimProjectionResult {
+    readonly written: boolean;
+    readonly targets: readonly RepoShimProjectionTargetResult[];
+    readonly workflowSnapshot?: WorkflowSnapshotExport;
+    readonly workflowSnapshotProjection?: WorkflowSnapshotProjectionResult;
+    readonly workflowSnapshotManifest?: WorkflowSnapshotManifestResult;
+    readonly errors: readonly string[];
+}
+export interface WorkflowSnapshotProjectionResult {
+    readonly path: string;
+    readonly written: boolean;
+    readonly status: "written" | "unchanged";
+    readonly errors: readonly string[];
+}
+export interface WorkflowSnapshotManifestResult {
+    readonly path: string;
+    readonly written: boolean;
+    readonly status: "written" | "unchanged";
+    readonly errors: readonly string[];
+}
+export interface WorkflowSnapshotManifestStatus {
+    readonly path: string;
+    readonly status: "missing" | "current" | "stale" | "drifted";
+    readonly expectedHash?: string;
+    readonly currentHash?: string;
+    readonly details?: string;
+}
+export interface RepoShimProjectionStatus {
+    readonly target: RepoShimKind;
+    readonly path: string;
+    readonly status: "missing" | "current" | "stale" | "drifted" | "unmanaged";
+}
+export interface RepoShimProjectionOptions {
+    readonly force?: boolean;
+}
+export declare function writeRepoShimProjections(projectPath: string, options?: RepoShimProjectionOptions): Promise<RepoShimProjectionResult>;
+export declare function readRepoShimProjectionStatuses(projectPath: string): Promise<readonly RepoShimProjectionStatus[]>;
+export declare function readWorkflowSnapshotManifestStatus(projectPath: string): Promise<WorkflowSnapshotManifestStatus>;
+//# sourceMappingURL=repo-shim-projection.d.ts.map

package/dist/application/repo-shim-projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-shim-projection.d.ts","sourceRoot":"","sources":["../../src/application/repo-shim-projection.ts"],"names":[],"mappings":"AAiBA,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,+BAA+B,CAAC;AAKvC,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAQ/C,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;IACrD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAC5D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,sBAAsB,CAAC;IACnD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,gCAAgC,CAAC;IACvE,QAAQ,CAAC,wBAAwB,CAAC,EAAE,8BAA8B,CAAC;IACnE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;CAC5E;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B;AAqBD,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,yBAA8B,GACtC,OAAO,CAAC,wBAAwB,CAAC,CA8DnC;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,wBAAwB,EAAE,CAAC,CA2CtH;AAED,wBAAsB,kCAAkC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,8BAA8B,CAAC,CAkCrH"}

package/dist/application/repo-shim-projection.js

@@ -0,0 +1,536 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join, relative } from "node:path";
+import { loadAgentDefinitions } from "./agent-loader.js";
+import { findInstructionProfile, loadInstructionProfiles, } from "./instruction-profile-loader.js";
+import { loadKilnConfig } from "../config/config-merger.js";
+import { collectProjectContextEvidence, readProjectContextMarkdown, } from "./project-context.js";
+import { buildWorkflowSnapshotExport, } from "./workflow-snapshot-export.js";
+const GENERATOR_VERSION = "repo-shims-v1";
+const SIGNATURE = "kiln:repo-shim:v1";
+const TARGETS = [
+    {
+        kind: "agents",
+        filename: "AGENTS.md",
+        audience: "Codex CLI and OpenCode",
+    },
+    {
+        kind: "claude",
+        filename: "CLAUDE.md",
+        audience: "Claude Code",
+    },
+];
+const WORKFLOW_SNAPSHOT_MARKDOWN_FILE = ".kiln/projections/workflow-snapshot.md";
+export async function writeRepoShimProjections(projectPath, options = {}) {
+    const results = [];
+    let workflowSnapshot;
+    let workflowSnapshotProjection;
+    let workflowSnapshotManifest;
+    try {
+        const agents = await loadAgentDefinitions(projectPath);
+        const instructionProfiles = loadInstructionProfiles(projectPath);
+        const kilnYaml = await loadKilnConfig(projectPath);
+        const repoContext = collectProjectContextEvidence(projectPath);
+        const adoptedProjectContext = readProjectContextMarkdown(projectPath);
+        const sourceProfiles = kilnYaml?.activeInstructionProfiles ?? [];
+        const projectRootId = hashText(repoContext.projectName.toLowerCase()).slice(0, 16);
+        for (const target of TARGETS) {
+            results.push(writeRepoShimTarget({
+                projectPath,
+                target,
+                agents,
+                instructionProfiles,
+                kilnYaml,
+                repoContext,
+                adoptedProjectContext,
+                sourceProfiles,
+                projectRootId,
+                force: options.force ?? false,
+            }));
+        }
+        workflowSnapshot = buildWorkflowSnapshotExport({
+            generatedAt: new Date().toISOString(),
+            generatedFiles: workflowSnapshotGeneratedFiles(),
+            projectContext: repoContext,
+            instructionProfiles,
+            kilnConfig: kilnYaml,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            written: false,
+            targets: [],
+            errors: [message],
+        };
+    }
+    const errors = results.flatMap((result) => [...result.errors]);
+    if (errors.length === 0 && workflowSnapshot) {
+        workflowSnapshotProjection = writeWorkflowSnapshotProjection(projectPath, workflowSnapshot);
+        workflowSnapshotManifest = writeWorkflowSnapshotManifest(projectPath, workflowSnapshot);
+    }
+    return {
+        written: errors.length === 0 && (results.some((result) => result.written)
+            || (workflowSnapshotProjection?.written ?? false)
+            || (workflowSnapshotManifest?.written ?? false)),
+        targets: results,
+        workflowSnapshot,
+        workflowSnapshotProjection,
+        workflowSnapshotManifest,
+        errors,
+    };
+}
+export async function readRepoShimProjectionStatuses(projectPath) {
+    const agents = await loadAgentDefinitions(projectPath);
+    const instructionProfiles = loadInstructionProfiles(projectPath);
+    const kilnYaml = await loadKilnConfig(projectPath);
+    const repoContext = collectProjectContextEvidence(projectPath);
+    const adoptedProjectContext = readProjectContextMarkdown(projectPath);
+    const sourceProfiles = kilnYaml?.activeInstructionProfiles ?? [];
+    const projectRootId = hashText(repoContext.projectName.toLowerCase()).slice(0, 16);
+    return TARGETS.map((target) => {
+        const path = join(projectPath, target.filename);
+        const expected = renderSignedProjection({
+            body: renderRepoShimBody({
+                projectPath,
+                target,
+                agents,
+                instructionProfiles,
+                kilnYaml,
+                repoContext,
+                adoptedProjectContext,
+            }),
+            target,
+            sourceProfiles,
+            projectRootId,
+            projectName: repoContext.projectName,
+        });
+        if (!existsSync(path)) {
+            return { target: target.kind, path, status: "missing" };
+        }
+        const existing = readFileSync(path, "utf-8");
+        const existingState = classifyExistingProjection(existing, target.kind);
+        if (existingState === "unmanaged" || existingState === "drifted") {
+            return { target: target.kind, path, status: existingState };
+        }
+        return {
+            target: target.kind,
+            path,
+            status: existing === expected ? "current" : "stale",
+        };
+    });
+}
+export async function readWorkflowSnapshotManifestStatus(projectPath) {
+    const manifestPath = workflowSnapshotManifestPath(projectPath);
+    if (!existsSync(manifestPath)) {
+        return { path: manifestPath, status: "missing" };
+    }
+    const content = readFileSync(manifestPath, "utf-8");
+    const currentHash = readManifestHash(content);
+    if (!currentHash) {
+        return {
+            path: manifestPath,
+            status: "drifted",
+            details: "workflow snapshot manifest is not valid JSON",
+        };
+    }
+    const expected = await buildCurrentWorkflowSnapshot(projectPath);
+    const expectedHash = expected.manifest.hash;
+    if (currentHash !== expectedHash) {
+        return {
+            path: manifestPath,
+            status: "stale",
+            expectedHash,
+            currentHash,
+            details: `workflow snapshot manifest hash is stale: expected ${expectedHash}, found ${currentHash}`,
+        };
+    }
+    return {
+        path: manifestPath,
+        status: "current",
+        expectedHash,
+        currentHash,
+    };
+}
+function writeRepoShimTarget(input) {
+    const targetPath = join(input.projectPath, input.target.filename);
+    const body = renderRepoShimBody(input);
+    const content = renderSignedProjection({
+        body,
+        target: input.target,
+        sourceProfiles: input.sourceProfiles,
+        projectRootId: input.projectRootId,
+        projectName: input.repoContext.projectName,
+    });
+    const existing = existsSync(targetPath) ? readFileSync(targetPath, "utf-8") : null;
+    const existingState = existing ? classifyExistingProjection(existing, input.target.kind) : "missing";
+    if (existingState === "unmanaged" && !input.force) {
+        return {
+            kind: input.target.kind,
+            path: targetPath,
+            written: false,
+            status: "blocked",
+            errors: [`${input.target.filename}: unmanaged guidance file exists; adopt or back up before generating repo shims`],
+        };
+    }
+    if (existingState === "drifted" && !input.force) {
+        return {
+            kind: input.target.kind,
+            path: targetPath,
+            written: false,
+            status: "blocked",
+            errors: [`${input.target.filename}: managed repo shim drift detected; rerun with --force after reviewing changes`],
+        };
+    }
+    if (existing === content) {
+        return {
+            kind: input.target.kind,
+            path: targetPath,
+            written: false,
+            status: "unchanged",
+            errors: [],
+        };
+    }
+    if (existing && input.force) {
+        backupExistingShim(input.projectPath, input.target.filename, existing);
+    }
+    writeFileSync(targetPath, content, "utf-8");
+    return {
+        kind: input.target.kind,
+        path: targetPath,
+        written: true,
+        status: "written",
+        errors: [],
+    };
+}
+function renderRepoShimBody(input) {
+    const { projectPath, target, agents, instructionProfiles, kilnYaml, repoContext, adoptedProjectContext } = input;
+    const domain = kilnYaml?.domain ?? "default";
+    const provider = kilnYaml?.provider ?? "provider default";
+    const model = kilnYaml?.model?.default ?? "provider default";
+    const maxDepth = String(kilnYaml?.maxDepth ?? 3);
+    const parallelWorkers = String(kilnYaml?.parallelWorkers ?? 1);
+    const rows = [...agents]
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map(formatAgentRow);
+    const lines = [
+        target.kind === "claude" ? "# Claude Project Guidance" : "# Agents",
+        "",
+        `> Generated by kiln sync --repo-shims for ${target.audience}. Do not edit manually.`,
+        "",
+        "## Project",
+        "",
+        `- Name: ${repoContext.projectName}`,
+        `- Domain: ${domain}`,
+        `- Default provider: ${provider}`,
+        `- Default model: ${model}`,
+        `- Max depth: ${maxDepth}`,
+        `- Parallel workers: ${parallelWorkers}`,
+        "",
+    ];
+    if (!adoptedProjectContext && (repoContext.packageManager || repoContext.scripts.length > 0 || repoContext.workspacePackages.length > 0)) {
+        lines.push("## Repository Evidence", "");
+        if (repoContext.packageManager) {
+            lines.push(`- Package manager: ${repoContext.packageManager}`);
+        }
+        for (const [name, command] of repoContext.scripts) {
+            lines.push(`- Script \`${name}\`: \`${command}\``);
+        }
+        for (const workspacePackage of repoContext.workspacePackages) {
+            lines.push(`- Workspace package: \`${workspacePackage}\``);
+        }
+        lines.push("");
+    }
+    if (!adoptedProjectContext && repoContext.docs.length > 0) {
+        lines.push("## Canonical Project References", "", ...repoContext.docs.map((doc) => `- ${doc}`), "");
+    }
+    if (adoptedProjectContext) {
+        lines.push("## Adopted Project Context", "", "Canonical source: `.kiln/project-context.md`.", "", stripFrontmatter(adoptedProjectContext).trim(), "");
+    }
+    if (kilnYaml?.activeInstructionProfiles && kilnYaml.activeInstructionProfiles.length > 0) {
+        const profileLines = kilnYaml.activeInstructionProfiles.map((profileId) => {
+            const profile = findInstructionProfile(instructionProfiles, profileId);
+            return profile
+                ? `- ${profile.name} (${profile.scope}): ${formatProfilePath(profile, projectPath)}${formatDoctrineSummary(profile.doctrine)}`
+                : `- ${profileId} (missing; create the canonical Kiln instruction profile before relying on this shim)`;
+        });
+        lines.push("## Active Instruction Profiles", "", "Read these canonical Kiln instruction profiles before work. They are the source of durable operator/team doctrine; this file is only a projection.", "", ...profileLines, "");
+    }
+    if (kilnYaml?.workGovernance) {
+        lines.push("## Work Governance", "", "Follow the resolved Kiln work-governance policy before choosing direct execution.", ...[
+            kilnYaml.workGovernance.defaultPosture ? `- Default posture: ${kilnYaml.workGovernance.defaultPosture}` : undefined,
+            kilnYaml.workGovernance.directExecution
+                ? `- Direct execution: ${formatDirectExecution(kilnYaml.workGovernance.directExecution)}`
+                : undefined,
+            kilnYaml.workGovernance.requireDelegationFor && kilnYaml.workGovernance.requireDelegationFor.length > 0
+                ? `- Orchestrate/delegate for: ${kilnYaml.workGovernance.requireDelegationFor.join(", ")}`
+                : undefined,
+            kilnYaml.workGovernance.requiredEvidence && kilnYaml.workGovernance.requiredEvidence.length > 0
+                ? `- Evidence before done: ${kilnYaml.workGovernance.requiredEvidence.join(", ")}`
+                : undefined,
+        ].filter((line) => line !== undefined), "");
+    }
+    lines.push("## Agents", "", "| Name | Display | Role | Tools | Model | Skills | Instruction Profiles |", "|------|---------|------|-------|-------|--------|----------------------|", ...rows, "");
+    if (rows.length === 0) {
+        lines.push("No agent profiles defined. Create `.kiln/agents/<name>.md` or `~/.kiln/agents/<name>.md` to add one.", "");
+    }
+    lines.push("## Usage", "", "Use canonical Kiln profiles, instruction profiles, and skills as the source of truth.", "Do not add durable workflow doctrine directly to this generated file.", "Update Kiln config and rerun `kiln sync --repo-shims` instead.", "");
+    return lines.join("\n");
+}
+function formatDirectExecution(config) {
+    if (!config) {
+        return "configured";
+    }
+    const parts = [
+        config.maxFiles !== undefined ? `maxFiles=${config.maxFiles}` : undefined,
+        config.maxRisk ? `maxRisk=${config.maxRisk}` : undefined,
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(", ") : "configured";
+}
+function formatAgentRow(agent) {
+    const tools = agent.tools && agent.tools.length > 0 ? agent.tools.join(", ") : "-";
+    const skills = agent.skills && agent.skills.length > 0 ? agent.skills.join(", ") : "-";
+    const taskAffinity = agent.taskAffinity && agent.taskAffinity.length > 0 ? `; tasks: ${agent.taskAffinity.join(", ")}` : "";
+    const displayName = agent.displayName ?? "-";
+    const instructionProfiles = agent.instructionProfiles && agent.instructionProfiles.length > 0
+        ? agent.instructionProfiles.join(", ")
+        : "-";
+    return `| ${agent.name} (${agent.scope}) | ${displayName} | ${agent.role}${taskAffinity} | ${tools} | ${agent.model ?? "-"} | ${skills} | ${instructionProfiles} |`;
+}
+function formatProfilePath(profile, projectPath) {
+    const normalizedPath = profile.filePath.replace(/\\/g, "/");
+    const globalMarker = "/.kiln/instructions/";
+    const globalIndex = normalizedPath.indexOf(globalMarker);
+    if (profile.scope === "global" && globalIndex >= 0) {
+        return `~/.kiln/instructions/${normalizedPath.slice(globalIndex + globalMarker.length)}`;
+    }
+    const relativePath = relative(projectPath, profile.filePath).replace(/\\/g, "/");
+    if (!relativePath.startsWith("..") && !relativePath.startsWith("/") && !/^[A-Za-z]:/.test(relativePath)) {
+        return relativePath;
+    }
+    return normalizedPath;
+}
+function renderSignedProjection(input) {
+    const contentHash = hashText(input.body);
+    return [
+        "<!--",
+        SIGNATURE,
+        `target: ${input.target.kind}`,
+        `projectName: ${input.projectName}`,
+        `projectRootId: sha256:${input.projectRootId}`,
+        `sourceProfiles: ${input.sourceProfiles.length > 0 ? input.sourceProfiles.join(",") : "-"}`,
+        `generator: ${GENERATOR_VERSION}`,
+        `contentHash: sha256:${contentHash}`,
+        "-->",
+        input.body,
+    ].join("\n");
+}
+function stripFrontmatter(content) {
+    const normalized = content.replace(/^\uFEFF/, "");
+    const match = /^---\s*\r?\n[\s\S]*?\r?\n---\s*([\s\S]*)$/u.exec(normalized);
+    return match?.[1] ?? normalized;
+}
+function classifyExistingProjection(content, expectedTarget) {
+    const metadata = readProjectionMetadata(content);
+    if (!metadata || metadata.target !== expectedTarget) {
+        return "unmanaged";
+    }
+    const body = content.slice(content.indexOf("-->") + 3).replace(/^\r?\n/, "");
+    return metadata.contentHash === `sha256:${hashText(body)}` ? "managed" : "drifted";
+}
+function readProjectionMetadata(content) {
+    const end = content.indexOf("-->");
+    if (!content.startsWith("<!--") || end === -1) {
+        return null;
+    }
+    const lines = content.slice(4, end).split(/\r?\n/).map((line) => line.trim());
+    if (!lines.includes(SIGNATURE)) {
+        return null;
+    }
+    const values = new Map();
+    for (const line of lines) {
+        const separator = line.indexOf(":");
+        if (separator > 0) {
+            values.set(line.slice(0, separator), line.slice(separator + 1).trim());
+        }
+    }
+    const target = values.get("target");
+    const contentHash = values.get("contentHash");
+    if (!target || !contentHash) {
+        return null;
+    }
+    return { target, contentHash };
+}
+function backupExistingShim(projectPath, filename, content) {
+    const backupDir = join(projectPath, ".kiln", "backups", "repo-shims");
+    mkdirSync(backupDir, { recursive: true });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    writeFileSync(join(backupDir, `${filename}.${timestamp}.bak`), content, "utf-8");
+}
+function writeWorkflowSnapshotManifest(projectPath, workflowSnapshot) {
+    const manifestPath = workflowSnapshotManifestPath(projectPath);
+    const existing = existsSync(manifestPath) ? readFileSync(manifestPath, "utf-8") : null;
+    const existingHash = existing ? readManifestHash(existing) : null;
+    if (existingHash === workflowSnapshot.manifest.hash) {
+        return {
+            path: manifestPath,
+            written: false,
+            status: "unchanged",
+            errors: [],
+        };
+    }
+    mkdirSync(join(projectPath, ".kiln", "projections"), { recursive: true });
+    writeFileSync(manifestPath, `${JSON.stringify(workflowSnapshot.manifest, null, 2)}\n`, "utf-8");
+    return {
+        path: manifestPath,
+        written: true,
+        status: "written",
+        errors: [],
+    };
+}
+function workflowSnapshotManifestPath(projectPath) {
+    return join(projectPath, ".kiln", "projections", "workflow-snapshot-manifest.json");
+}
+function readManifestHash(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return typeof parsed.hash === "string" ? parsed.hash : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function buildCurrentWorkflowSnapshot(projectPath) {
+    const instructionProfiles = loadInstructionProfiles(projectPath);
+    const kilnYaml = await loadKilnConfig(projectPath);
+    return buildWorkflowSnapshotExport({
+        generatedAt: new Date().toISOString(),
+        generatedFiles: workflowSnapshotGeneratedFiles(),
+        projectContext: collectProjectContextEvidence(projectPath),
+        instructionProfiles,
+        kilnConfig: kilnYaml,
+    });
+}
+function workflowSnapshotGeneratedFiles() {
+    return [
+        ...TARGETS.map((target) => target.filename),
+        WORKFLOW_SNAPSHOT_MARKDOWN_FILE,
+    ];
+}
+function writeWorkflowSnapshotProjection(projectPath, workflowSnapshot) {
+    const snapshotPath = workflowSnapshotMarkdownPath(projectPath);
+    const content = renderWorkflowSnapshotMarkdown(workflowSnapshot);
+    const existing = existsSync(snapshotPath) ? readFileSync(snapshotPath, "utf-8") : null;
+    if (existing === content) {
+        return {
+            path: snapshotPath,
+            written: false,
+            status: "unchanged",
+            errors: [],
+        };
+    }
+    mkdirSync(join(projectPath, ".kiln", "projections"), { recursive: true });
+    writeFileSync(snapshotPath, content, "utf-8");
+    return {
+        path: snapshotPath,
+        written: true,
+        status: "written",
+        errors: [],
+    };
+}
+function workflowSnapshotMarkdownPath(projectPath) {
+    return join(projectPath, WORKFLOW_SNAPSHOT_MARKDOWN_FILE);
+}
+function renderWorkflowSnapshotMarkdown(workflowSnapshot) {
+    const body = renderWorkflowSnapshotBody(workflowSnapshot);
+    return [
+        "<!--",
+        "kiln:workflow-snapshot:v1",
+        `generator: ${workflowSnapshot.manifest.generator}`,
+        `contentHash: sha256:${hashText(body)}`,
+        "-->",
+        body,
+    ].join("\n");
+}
+function renderWorkflowSnapshotBody(workflowSnapshot) {
+    const lines = [
+        "# Kiln Workflow Snapshot",
+        "",
+        "> Generated by kiln sync --repo-shims from canonical Kiln workflow evidence. Do not edit manually.",
+        "",
+        "## Manifest",
+        "",
+        `- Hash: ${workflowSnapshot.manifest.hash}`,
+        `- Sources: ${workflowSnapshot.manifest.sourceIds.join(", ")}`,
+        `- Generated files: ${workflowSnapshot.manifest.generatedFiles.join(", ")}`,
+        "",
+        "## Specification",
+        "",
+        `- Project: ${workflowSnapshot.specification.projectName}`,
+        `- Package manager: ${workflowSnapshot.specification.packageManager ?? "unknown"}`,
+        `- Workspaces: ${formatSnapshotList(workflowSnapshot.specification.workspacePackages)}`,
+        `- Canonical docs: ${formatSnapshotList(workflowSnapshot.specification.canonicalDocs)}`,
+        "",
+        "## Plan",
+        "",
+        `- Default posture: ${workflowSnapshot.plan.defaultPosture ?? "unspecified"}`,
+        `- Orchestration triggers: ${formatSnapshotList(workflowSnapshot.plan.orchestrationTriggers)}`,
+        `- Evidence before done: ${formatSnapshotList(workflowSnapshot.plan.evidenceBeforeDone)}`,
+        "",
+        "## Authority",
+        "",
+        `- Default posture: ${workflowSnapshot.authorityPosture.defaultPosture ?? "unspecified"}`,
+        `- Direct execution: ${formatDirectExecutionSnapshot(workflowSnapshot.authorityPosture.directExecution)}`,
+        "",
+        "## Model Policy",
+        "",
+        `- Default provider: ${workflowSnapshot.modelPolicyGuidance.defaultProvider ?? "provider default"}`,
+        `- Default model: ${workflowSnapshot.modelPolicyGuidance.defaultModel ?? "provider default"}`,
+        `- Max depth: ${workflowSnapshot.modelPolicyGuidance.maxDepth ?? "unspecified"}`,
+        `- Parallel workers: ${workflowSnapshot.modelPolicyGuidance.parallelWorkers ?? "unspecified"}`,
+        "",
+        "## Work Item Profiles",
+        "",
+        "| Profile | Risk | Evidence | Gates |",
+        "|---------|------|----------|-------|",
+        ...workflowSnapshot.workItems.map((profile) => `| ${profile.id} | ${profile.minimumRisk} | ${formatSnapshotList(profile.requiredEvidence)} | ${formatSnapshotList(profile.verificationGates)} |`),
+        "",
+        "## Instruction Profiles",
+        "",
+        ...(workflowSnapshot.instructionProfiles.length > 0
+            ? workflowSnapshot.instructionProfiles.map((profile) => `- ${profile.id} (${profile.scope}): ${profile.sourcePath}${profile.doctrineFacets.length > 0 ? ` - ${profile.doctrineFacets.join(", ")}` : ""}`)
+            : ["- none"]),
+        "",
+    ];
+    return lines.join("\n");
+}
+function formatSnapshotList(values) {
+    return values.length > 0 ? values.join(", ") : "none";
+}
+function formatDirectExecutionSnapshot(directExecution) {
+    if (!directExecution) {
+        return "unspecified";
+    }
+    const parts = [
+        directExecution.maxFiles !== undefined ? `maxFiles=${directExecution.maxFiles}` : undefined,
+        directExecution.maxRisk ? `maxRisk=${directExecution.maxRisk}` : undefined,
+    ].filter((part) => part !== undefined);
+    return parts.length > 0 ? parts.join(", ") : "configured";
+}
+function hashText(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function formatDoctrineSummary(doctrine) {
+    if (!doctrine) {
+        return "";
+    }
+    const facets = [
+        doctrine.principles && doctrine.principles.length > 0 ? "principles" : undefined,
+        doctrine.workflow && doctrine.workflow.length > 0 ? "workflow" : undefined,
+        doctrine.qualityGates && doctrine.qualityGates.length > 0 ? "quality gates" : undefined,
+        doctrine.reviewPosture && doctrine.reviewPosture.length > 0 ? "review posture" : undefined,
+        doctrine.delegation && doctrine.delegation.length > 0 ? "delegation" : undefined,
+    ].filter((facet) => facet !== undefined);
+    return facets.length > 0 ? ` - doctrine: ${facets.join(", ")}` : "";
+}
+//# sourceMappingURL=repo-shim-projection.js.map