@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/compiled-compile.js

@@ -1,274 +1 @@
-import { join } from "node:path";
-import { createStageExecutionShell, freezeStageExecutionShell, pruneStageExecutionShells, syncStageExecutionShellWrites, } from "./agent-shells.js";
-import { readInterfConfig, refreshCompiledBootstrapGuidance, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, } from "./interf.js";
-import { reconcileCompiledStageRun, } from "./runtime-reconcile.js";
-import { refreshCompiledArtifacts, } from "./state.js";
-import { buildRuntimeStageContract, } from "./runtime.js";
-import { validateWorkflowPackage } from "./local-workflows.js";
-import { formatActiveCompiledWorkflowStageStep, getActiveCompiledStagePolicyNotes, getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, resolveActiveCompiledStageAcceptance, } from "./workflow-definitions.js";
-import { validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
-import { buildLocalSkillContractExtension, buildStageInstructions, reportBlankLine, reportLine, reportValidationFailure, workflowCompileStageDirectory, } from "./workflow-helpers.js";
-import { executeValidatedStage, } from "./workflow-stage-runner.js";
-import { syncCompiledRawSnapshot } from "./compiled-raw.js";
-import { workflowPackagePathForCompiled, } from "./compiled-paths.js";
-import { compiledContractArtifactPathsForZoneIds, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { listFilesRecursive } from "./filesystem.js";
-export function resolveCompiledContext(compiledPath) {
-    const config = readInterfConfig(compiledPath);
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${compiledPath}`);
-    return {
-        compiledName: config?.name ?? "compiled",
-        sourcePath: resolveSourceFolderPath(compiledPath, config),
-        controlPath: resolveSourceControlPath(compiledPath),
-        workflowId,
-    };
-}
-export function compiledExecutionStages(workflowId, compiledPath) {
-    return getActiveCompiledWorkflow(compiledPath, workflowId)
-        .stages;
-}
-function zoneArtifactCount(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
-    try {
-        if (kind === "file") {
-            return listFilesRecursive(absolutePath).length > 0 ? 1 : 0;
-        }
-    }
-    catch {
-        if (kind === "file")
-            return 0;
-    }
-    return listFilesRecursive(absolutePath).length;
-}
-function resolveStageContractArtifacts(compiledPath, stageDefinition) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    if (!schema) {
-        throw new Error(`Missing compiled schema for stage "${stageDefinition.id}" at ${workflowPackagePathForCompiled(compiledPath)}.`);
-    }
-    return {
-        reads: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.reads),
-        writes: compiledContractArtifactPathsForZoneIds(schema, stageDefinition.writes),
-    };
-}
-function buildStageCounts(compiledPath, stageDefinition) {
-    const context = resolveCompiledContext(compiledPath);
-    const sourceTotal = discoverSourceFiles(context.sourcePath, compiledPath).totalCount;
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    const zoneCounts = {};
-    if (schema) {
-        for (const zoneId of new Set([...stageDefinition.reads, ...stageDefinition.writes])) {
-            const zone = findCompiledSchemaZone(schema, zoneId);
-            if (!zone)
-                continue;
-            zoneCounts[zoneId] = zoneArtifactCount(compiledPath, zone.path, zone.kind);
-        }
-    }
-    return {
-        source_total: sourceTotal,
-        read_zone_total: stageDefinition.reads.length,
-        write_zone_total: stageDefinition.writes.length,
-        ...zoneCounts,
-    };
-}
-function buildStageContract(compiledPath, workflowId, stageDefinition) {
-    const config = readInterfConfig(compiledPath);
-    const localSkills = buildLocalSkillContractExtension(compiledPath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this workflow stage while still honoring the declared reads, writes, and proof rules.");
-    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
-    const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
-    return buildRuntimeStageContract({
-        compiledName: config?.name ?? "compiled",
-        stageId: stageDefinition.id,
-        stageLabel: stageDefinition.label,
-        counts: buildStageCounts(compiledPath, stageDefinition),
-        stageReadArtifacts: stageArtifacts.reads,
-        stageWriteArtifacts: stageArtifacts.writes,
-        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, workflowId, stageDefinition.id),
-        localSkillDocs: localSkills.reads,
-        instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, workflowId, stageDefinition.id),
-    });
-}
-async function runCompiledStage(options) {
-    const context = resolveCompiledContext(options.compiledPath);
-    const stageDefinition = options.stageDefinition;
-    const contract = buildStageContract(options.compiledPath, context.workflowId, stageDefinition);
-    const localSkills = buildLocalSkillContractExtension(options.compiledPath, [workflowCompileStageDirectory(stageDefinition.skillDir)], "Use them to refine this workflow stage while still honoring the declared reads, writes, and proof rules.");
-    const instructions = buildStageInstructions(stageDefinition.skillDir, localSkills);
-    if (options.reportStep !== false) {
-        reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, context.workflowId, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
-    }
-    const shell = createStageExecutionShell(options.compiledPath, context.compiledName, context.workflowId, stageDefinition, contract.artifacts.writes);
-    try {
-        return await executeValidatedStage({
-            executor: options.executor,
-            compiledPath: options.compiledPath,
-            executionPath: shell.rootPath,
-            targetName: context.compiledName,
-            workflow: context.workflowId,
-            workflowSourcePath: options.compiledPath,
-            stageDefinition,
-            instructions,
-            summary: `Executing ${stageDefinition.label.toLowerCase()}.`,
-            contract,
-            statusLines: [
-                `Emit exactly one startup line: STATUS: loaded ${stageDefinition.label.toLowerCase()} stage.`,
-                "Emit STATUS: reading declared inputs after you confirm the shell contract and local docs.",
-                "Emit STATUS: writing declared outputs after the stage starts updating the compiled zones.",
-                `Emit DONE: ${stageDefinition.id} complete when the declared outputs and proof are on disk.`,
-            ],
-            reporter: options.reporter,
-            completionCheck: () => validateCompiledStage(options.compiledPath, stageDefinition.id).ok,
-            syncWrites: () => syncStageExecutionShellWrites(options.compiledPath, shell.rootPath, stageDefinition, contract.artifacts.writes),
-            reconcile: () => reconcileCompiledStageRun(options.compiledPath, stageDefinition),
-            refreshArtifacts: () => refreshCompiledArtifacts(options.compiledPath, { ensureViewSpec: true }),
-            validate: () => validateCompiledStage(options.compiledPath, stageDefinition.id),
-        });
-    }
-    finally {
-        freezeStageExecutionShell(shell.rootPath);
-    }
-}
-export async function runCompiledSummarize(options) {
-    const context = resolveCompiledContext(options.compiledPath);
-    const stageDefinition = options.stageDefinition
-        ?? compiledExecutionStages(context.workflowId, options.compiledPath).find((stage) => stage.id === "summarize");
-    if (!stageDefinition) {
-        return {
-            ok: false,
-            code: 1,
-            skipped: true,
-            plan: { sourceCount: 0, summaryCount: 0, targetCount: 0 },
-            summary: "Workflow does not declare a summarize stage.",
-        };
-    }
-    const sourceCount = discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount;
-    const result = await runCompiledStage({
-        executor: options.executor,
-        compiledPath: options.compiledPath,
-        reporter: options.reporter,
-        reportStep: options.reportStep,
-        stageDefinition,
-    });
-    return {
-        ...result,
-        skipped: false,
-        plan: {
-            sourceCount,
-            summaryCount: 0,
-            targetCount: sourceCount,
-        },
-    };
-}
-export async function runCompiledCompile(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
-    }
-    let lastResult = { ok: true, code: 0 };
-    try {
-        const context = resolveCompiledContext(options.compiledPath);
-        for (const stageDefinition of compiledExecutionStages(context.workflowId, options.compiledPath)) {
-            const result = await runCompiledStage({
-                executor: options.executor,
-                compiledPath: options.compiledPath,
-                reporter: options.reporter,
-                reportStep: options.reportStep,
-                stageDefinition,
-            });
-            lastResult = result;
-            if (!result.ok)
-                return result;
-        }
-        return lastResult;
-    }
-    finally {
-        if (preserveMode !== "always" && lastResult.ok) {
-            pruneStageExecutionShells(options.compiledPath);
-        }
-    }
-}
-export async function compileCompiled(options) {
-    const preserveMode = options.preserveStageShells ?? "on-failure";
-    if (preserveMode !== "always") {
-        pruneStageExecutionShells(options.compiledPath);
-    }
-    let result = {
-        ok: true,
-        stageResults: {},
-        failedStage: null,
-        summarize: null,
-        structure: null,
-        shape: null,
-        compile: null,
-    };
-    try {
-        const sourceInputPath = resolveSourceInputPath(options.compiledPath);
-        syncCompiledRawSnapshot(options.compiledPath, sourceInputPath);
-        refreshCompiledBootstrapGuidance(options.compiledPath);
-        const workflowValidation = validateWorkflowPackage(join(options.compiledPath, ".interf", "workflow"));
-        if (!workflowValidation.ok) {
-            reportValidationFailure(options.reporter, workflowValidation.summary, workflowValidation.errors);
-            return {
-                ...result,
-                ok: false,
-                failedStage: "workflow",
-                compile: {
-                    ok: false,
-                    code: 1,
-                    summary: workflowValidation.summary,
-                },
-            };
-        }
-        const context = resolveCompiledContext(options.compiledPath);
-        const stages = compiledExecutionStages(context.workflowId, options.compiledPath);
-        for (const stageDefinition of stages) {
-            const stageResult = await runCompiledStage({
-                executor: options.executor,
-                compiledPath: options.compiledPath,
-                reporter: options.reporter,
-                reportStep: true,
-                stageDefinition,
-            });
-            result.stageResults[stageDefinition.id] = stageResult;
-            if (stageDefinition.id === "summarize") {
-                result.summarize = {
-                    ...stageResult,
-                    skipped: false,
-                    plan: {
-                        sourceCount: discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount,
-                        summaryCount: 0,
-                        targetCount: discoverSourceFiles(context.sourcePath, options.compiledPath).totalCount,
-                    },
-                };
-            }
-            else if (stageDefinition.id === "structure") {
-                result.structure = stageResult;
-            }
-            else if (stageDefinition.id === "shape") {
-                result.shape = stageResult;
-            }
-            if (!stageResult.ok) {
-                result.ok = false;
-                result.failedStage = stageDefinition.id;
-                result.compile = stageResult;
-                return result;
-            }
-        }
-        const workflowValidationResult = validateCompiledWorkflow(options.compiledPath);
-        result.ok = workflowValidationResult.ok;
-        result.failedStage = workflowValidationResult.ok ? null : workflowValidationResult.stage;
-        result.compile = {
-            ok: workflowValidationResult.ok,
-            code: workflowValidationResult.ok ? 0 : 1,
-            summary: workflowValidationResult.summary,
-        };
-        return result;
-    }
-    finally {
-        if (preserveMode !== "always" && result.ok) {
-            pruneStageExecutionShells(options.compiledPath);
-        }
-    }
-}
+export * from "../packages/compiler/compiled-compile.js";

package/dist/lib/compiled-paths.d.ts

@@ -1,39 +1 @@
-export declare const COMPILED_INTERF_DIR = ".interf";
-export declare const COMPILED_CONFIG_FILE = "interf.json";
-export declare const COMPILED_WORKFLOW_DIR = "workflow";
-export declare const COMPILED_TEST_DIR = "tests";
-export declare const COMPILED_TEST_TARGETS_DIR = "targets";
-export declare const COMPILED_RUNTIME_DIR = "runtime";
-export declare const COMPILED_RUNTIME_STATE_FILE = "state.json";
-export declare const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
-export declare const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export declare const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
-export declare const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
-export declare const COMPILED_RUNTIME_RUN_FILE = "run.json";
-export declare const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export declare const COMPILED_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export declare function compiledRuntimeRoot(compiledPath: string): string;
-export declare function compiledRuntimeFilePath(compiledPath: string, fileName: string): string;
-export declare function compiledInterfRoot(compiledPath: string): string;
-export declare function compiledInterfConfigPath(compiledPath: string): string;
-export declare function workflowPackagePathForCompiled(compiledPath: string): string;
-export declare function testRootForCompiled(compiledPath: string): string;
-export declare function testTargetsRootForCompiled(compiledPath: string): string;
-export declare function stageExecutionShellsRoot(compiledPath: string): string;
-export declare function workflowImprovementLoopsRoot(compiledPath: string): string;
-export declare function workflowImprovementRunRoot(compiledPath: string, runId: string): string;
-export declare function workflowImprovementLoopRoot(compiledPath: string, runId: string, loopIndex: number): string;
-export declare function targetTestRunsRootForCompiled(compiledPath: string): string;
-export declare function targetTestSandboxesRootForCompiled(compiledPath: string): string;
-export declare function compiledRuntimeLogsRoot(compiledPath: string): string;
-export declare function compiledQueryAcceptanceRoot(compiledPath: string): string;
-export declare function compiledRuntimeStatePath(compiledPath: string): string;
-export declare function compiledRuntimeHealthPath(compiledPath: string): string;
-export declare function compiledRuntimeViewSpecPath(compiledPath: string): string;
-export declare function compiledRawSnapshotMetadataPath(compiledPath: string): string;
-export declare function compiledRuntimeInventoryPath(compiledPath: string): string;
-export declare function compiledRuntimeRunPath(compiledPath: string): string;
-export declare function compiledRuntimeRunHistoryPath(compiledPath: string): string;
-export declare function compiledRuntimeStageContractPath(compiledPath: string): string;
-export declare function resolveSourceControlPathForCompiled(compiledPath: string): string;
-export declare function defaultControlPathForCompiled(compiledPath: string): string;
+export * from "../packages/project-model/compiled-paths.js";

package/dist/lib/compiled-paths.js

@@ -1,103 +1,3 @@
-import { basename, dirname, join, relative, resolve, sep } from "node:path";
-export const COMPILED_INTERF_DIR = ".interf";
-export const COMPILED_CONFIG_FILE = "interf.json";
-export const COMPILED_WORKFLOW_DIR = "workflow";
-export const COMPILED_TEST_DIR = "tests";
-export const COMPILED_TEST_TARGETS_DIR = "targets";
-export const COMPILED_RUNTIME_DIR = "runtime";
-export const COMPILED_RUNTIME_STATE_FILE = "state.json";
-export const COMPILED_RUNTIME_HEALTH_FILE = "health.json";
-export const COMPILED_RUNTIME_VIEW_SPEC_FILE = "view-spec.json";
-export const COMPILED_RUNTIME_RAW_SNAPSHOT_FILE = "raw-snapshot.json";
-export const COMPILED_RUNTIME_INVENTORY_FILE = "inventory.json";
-export const COMPILED_RUNTIME_RUN_FILE = "run.json";
-export const COMPILED_RUNTIME_RUN_HISTORY_FILE = "run-history.jsonl";
-export const COMPILED_RUNTIME_STAGE_CONTRACT_FILE = "stage-contract.json";
-export function compiledRuntimeRoot(compiledPath) {
-    return join(compiledPath, COMPILED_INTERF_DIR, COMPILED_RUNTIME_DIR);
-}
-export function compiledRuntimeFilePath(compiledPath, fileName) {
-    return join(compiledRuntimeRoot(compiledPath), fileName);
-}
-export function compiledInterfRoot(compiledPath) {
-    return join(compiledPath, COMPILED_INTERF_DIR);
-}
-export function compiledInterfConfigPath(compiledPath) {
-    return join(compiledInterfRoot(compiledPath), COMPILED_CONFIG_FILE);
-}
-export function workflowPackagePathForCompiled(compiledPath) {
-    return join(compiledInterfRoot(compiledPath), COMPILED_WORKFLOW_DIR);
-}
-export function testRootForCompiled(compiledPath) {
-    return join(compiledInterfRoot(compiledPath), COMPILED_TEST_DIR);
-}
-export function testTargetsRootForCompiled(compiledPath) {
-    return join(testRootForCompiled(compiledPath), COMPILED_TEST_TARGETS_DIR);
-}
-export function stageExecutionShellsRoot(compiledPath) {
-    return join(compiledRuntimeRoot(compiledPath), "execution-shells");
-}
-export function workflowImprovementLoopsRoot(compiledPath) {
-    return join(compiledRuntimeRoot(compiledPath), "improvement-loops");
-}
-export function workflowImprovementRunRoot(compiledPath, runId) {
-    return join(workflowImprovementLoopsRoot(compiledPath), runId);
-}
-export function workflowImprovementLoopRoot(compiledPath, runId, loopIndex) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), `loop-${String(loopIndex).padStart(2, "0")}`);
-}
-export function targetTestRunsRootForCompiled(compiledPath) {
-    return join(testTargetsRootForCompiled(compiledPath), "runs");
-}
-export function targetTestSandboxesRootForCompiled(compiledPath) {
-    return join(testTargetsRootForCompiled(compiledPath), "sandboxes");
-}
-export function compiledRuntimeLogsRoot(compiledPath) {
-    return join(compiledRuntimeRoot(compiledPath), "logs");
-}
-export function compiledQueryAcceptanceRoot(compiledPath) {
-    return join(compiledRuntimeRoot(compiledPath), "query-acceptance");
-}
-export function compiledRuntimeStatePath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_STATE_FILE);
-}
-export function compiledRuntimeHealthPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_HEALTH_FILE);
-}
-export function compiledRuntimeViewSpecPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_VIEW_SPEC_FILE);
-}
-export function compiledRawSnapshotMetadataPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RAW_SNAPSHOT_FILE);
-}
-export function compiledRuntimeInventoryPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_INVENTORY_FILE);
-}
-export function compiledRuntimeRunPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RUN_FILE);
-}
-export function compiledRuntimeRunHistoryPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_RUN_HISTORY_FILE);
-}
-export function compiledRuntimeStageContractPath(compiledPath) {
-    return compiledRuntimeFilePath(compiledPath, COMPILED_RUNTIME_STAGE_CONTRACT_FILE);
-}
-export function resolveSourceControlPathForCompiled(compiledPath) {
-    let cursor = resolve(compiledPath);
-    while (true) {
-        const parent = dirname(cursor);
-        if (basename(parent) === "interf" &&
-            basename(cursor) !== "tests" &&
-            basename(cursor) !== "workflows") {
-            return dirname(parent);
-        }
-        if (parent === cursor)
-            break;
-        cursor = parent;
-    }
-    throw new Error(`Compiled dataset is not under the canonical project layout: ${compiledPath}`);
-}
-export function defaultControlPathForCompiled(compiledPath) {
-    const relativePath = relative(compiledPath, resolveSourceControlPathForCompiled(compiledPath));
-    return relativePath.length > 0 ? relativePath.split(sep).join("/") : ".";
-}
+// Compatibility shim for historical `src/lib/compiled-paths.ts` imports.
+// Source of truth: `src/packages/project-model/compiled-paths.ts`.
+export * from "../packages/project-model/compiled-paths.js";

package/dist/lib/compiled-raw.d.ts

@@ -1,49 +1 @@
-import type { InterfConfig } from "./schema.js";
-export interface CompiledRawSyncResult {
-    sourceTotal: number;
-    copied: number;
-    removed: number;
-}
-type RawSnapshotMaterializeMode = "copy" | "link-or-copy";
-export declare function resolveCompiledRawPath(compiledPath: string, config?: {
-    [x: string]: unknown;
-    type: "compiled";
-    name: string;
-    workflow: string;
-    checks: {
-        question: string;
-        id?: string | undefined;
-        answer?: string | undefined;
-        expect?: {
-            must_include?: string[] | undefined;
-            must_include_one_of?: string[][] | undefined;
-            must_not_include?: string[] | undefined;
-            min_words?: number | undefined;
-            max_words?: number | undefined;
-        } | undefined;
-        strictness?: string | undefined;
-    }[];
-    source: {
-        path: string;
-        dataset_path: string;
-        control_path?: string | undefined;
-    };
-    about?: string | undefined;
-    max_attempts?: number | undefined;
-    max_loops?: number | undefined;
-    workflow_origin?: {
-        selected: string;
-        local_draft?: boolean | undefined;
-    } | undefined;
-} | null): string;
-export declare function syncCompiledRawSnapshot(compiledPath: string, sourcePath?: string): CompiledRawSyncResult;
-export declare function ensureCompiledRawBinding(compiledPath: string): InterfConfig | null;
-export declare function projectRawSnapshot(options: {
-    sourcePath: string;
-    destinationPath: string;
-    compiledPath: string;
-    mode?: RawSnapshotMaterializeMode;
-    prune?: boolean;
-    preserveTimestamps?: boolean;
-}): CompiledRawSyncResult;
-export {};
+export * from "../packages/project-model/compiled-raw.js";

package/dist/lib/compiled-raw.js

@@ -1,102 +1,3 @@
-import { cpSync, existsSync, linkSync, mkdirSync, rmSync, statSync, } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import { listFilesRecursive } from "./filesystem.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { readInterfConfig, resolveSourceInputPath, } from "./interf-detect.js";
-import { saveCompiledInterfConfig } from "./source-config.js";
-import { defaultControlPathForCompiled, } from "./compiled-paths.js";
-import { assertPathWithinRoot } from "./util.js";
-export function resolveCompiledRawPath(compiledPath, config = readInterfConfig(compiledPath)) {
-    const configuredPath = typeof config?.source?.path === "string" && config.source.path.length > 0
-        ? config.source.path
-        : "raw";
-    return assertPathWithinRoot(compiledPath, resolve(compiledPath, configuredPath), "Compiled raw path");
-}
-export function syncCompiledRawSnapshot(compiledPath, sourcePath = resolveSourceInputPath(compiledPath)) {
-    ensureCompiledRawBinding(compiledPath);
-    const rawPath = resolveCompiledRawPath(compiledPath);
-    return projectRawSnapshot({
-        sourcePath,
-        destinationPath: rawPath,
-        compiledPath,
-        mode: "copy",
-        prune: true,
-        preserveTimestamps: true,
-    });
-}
-export function ensureCompiledRawBinding(compiledPath) {
-    const config = readInterfConfig(compiledPath);
-    if (!config)
-        return null;
-    if (config.source?.path === "./raw")
-        return config;
-    const nextConfig = {
-        ...config,
-        source: {
-            ...(config.source ?? {}),
-            path: "./raw",
-            control_path: config.source?.control_path ?? defaultControlPathForCompiled(compiledPath),
-            ...(config.source?.dataset_path ? { dataset_path: config.source.dataset_path } : {}),
-        },
-    };
-    return saveCompiledInterfConfig(compiledPath, nextConfig);
-}
-function filesMatch(sourcePath, targetPath) {
-    if (!existsSync(targetPath))
-        return false;
-    try {
-        const sourceStat = statSync(sourcePath);
-        const targetStat = statSync(targetPath);
-        return sourceStat.size === targetStat.size && sourceStat.mtimeMs === targetStat.mtimeMs;
-    }
-    catch {
-        return false;
-    }
-}
-function materializeRawSnapshotFile(sourcePath, targetPath, options) {
-    mkdirSync(dirname(targetPath), { recursive: true });
-    rmSync(targetPath, { force: true });
-    if (options.mode === "link-or-copy") {
-        try {
-            linkSync(sourcePath, targetPath);
-            return;
-        }
-        catch {
-            // fall through to copy
-        }
-    }
-    cpSync(sourcePath, targetPath, { preserveTimestamps: options.preserveTimestamps });
-}
-export function projectRawSnapshot(options) {
-    const discovery = discoverSourceFiles(options.sourcePath, options.compiledPath);
-    const expectedFiles = new Set(discovery.sourceFiles);
-    mkdirSync(options.destinationPath, { recursive: true });
-    let removed = 0;
-    if (options.prune !== false) {
-        for (const existingPath of listFilesRecursive(options.destinationPath)) {
-            const relativePath = relative(options.destinationPath, existingPath);
-            if (expectedFiles.has(relativePath))
-                continue;
-            rmSync(existingPath, { force: true });
-            removed += 1;
-        }
-    }
-    let copied = 0;
-    for (const relativePath of discovery.sourceFiles) {
-        const sourceFilePath = join(options.sourcePath, relativePath);
-        const targetFilePath = join(options.destinationPath, relativePath);
-        if (filesMatch(sourceFilePath, targetFilePath)) {
-            continue;
-        }
-        materializeRawSnapshotFile(sourceFilePath, targetFilePath, {
-            mode: options.mode ?? "copy",
-            preserveTimestamps: options.preserveTimestamps ?? true,
-        });
-        copied += 1;
-    }
-    return {
-        sourceTotal: discovery.totalCount,
-        copied,
-        removed,
-    };
-}
+// Compatibility shim for historical `src/lib/compiled-raw.ts` imports.
+// Source of truth: `src/packages/project-model/compiled-raw.ts`.
+export * from "../packages/project-model/compiled-raw.js";

package/dist/lib/compiled-reset.d.ts

@@ -1 +1 @@
-export declare function resetCompiledGeneratedState(compiledPath: string, scope?: "compile" | "all"): void;
+export * from "../packages/project-model/compiled-reset.js";

package/dist/lib/compiled-reset.js

@@ -1,44 +1,3 @@
-import { existsSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { compiledKnowledgeRootPath, compiledSummariesPath, } from "./compiled-schema.js";
-import { initCompiledState, refreshCompiledArtifacts, saveState, } from "./state.js";
-import { saveEmptyCompiledInventory } from "./state-io.js";
-import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
-function removeIfExists(path) {
-    if (existsSync(path)) {
-        rmSync(path, { recursive: true, force: true });
-    }
-}
-const COMPILE_RUNTIME_RESET_ENTRIES = [
-    "state.json",
-    "health.json",
-    "view-spec.json",
-    "inventory.json",
-    "run.json",
-    "stage-contract.json",
-    "summarize-targets.json",
-];
-function resetCompiledRuntimeFiles(compiledPath) {
-    const runtimeRoot = compiledRuntimeRoot(compiledPath);
-    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
-        removeIfExists(join(runtimeRoot, entry));
-    }
-    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
-}
-export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
-    removeIfExists(compiledSummariesPath(compiledPath));
-    removeIfExists(compiledKnowledgeRootPath(compiledPath));
-    removeIfExists(join(compiledPath, ".obsidian"));
-    resetCompiledRuntimeFiles(compiledPath);
-    saveState(compiledPath, initCompiledState());
-    saveEmptyCompiledInventory(compiledPath);
-    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
-    if (scope === "all") {
-        removeIfExists(stageExecutionShellsRoot(compiledPath));
-        removeIfExists(workflowImprovementLoopsRoot(compiledPath));
-        removeIfExists(compiledRuntimeLogsRoot(compiledPath));
-        removeIfExists(join(compiledRuntimeRoot(compiledPath), "run-history.jsonl"));
-        removeIfExists(testRootForCompiled(compiledPath));
-        removeIfExists(testTargetsRootForCompiled(compiledPath));
-    }
-}
+// Compatibility shim for historical `src/lib/compiled-reset.ts` imports.
+// Source of truth: `src/packages/project-model/compiled-reset.ts`.
+export * from "../packages/project-model/compiled-reset.js";

package/dist/lib/compiled-schema.d.ts

@@ -1,27 +1 @@
-import { type BuiltinCompiledZoneId } from "./builtin-compiled-workflow.js";
-import { type WorkflowCompiledSchema, type WorkflowCompiledZone, type WorkflowZoneId } from "./schema.js";
-export interface WorkflowSchemaStageLike {
-    id: string;
-    writes: readonly string[];
-}
-export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
-export declare const COMPILED_SCHEMA_FILE = "compiled.schema.json";
-export declare function compiledSchemaFilePath(rootPath: string): string;
-export declare function compiledSchemaRelativePath(): string;
-export declare function listCompiledSchemaZones(schema: WorkflowCompiledSchema): WorkflowCompiledZone[];
-export declare function findCompiledSchemaZone(schema: WorkflowCompiledSchema, zoneId: WorkflowZoneId): WorkflowCompiledZone | null;
-export declare function compiledZoneAbsolutePath(compiledPath: string, zone: Pick<WorkflowCompiledZone, "path">): string;
-export declare function compiledContractArtifactPath(zone: Pick<WorkflowCompiledZone, "path" | "kind">): string;
-export declare function compiledContractArtifactPathsForZoneIds(schema: WorkflowCompiledSchema, zoneIds: readonly WorkflowZoneId[]): string[];
-export declare function builtinCompiledZoneRelativePath(zoneId: BuiltinCompiledZoneId): string;
-export declare function builtinCompiledZoneAbsolutePath(compiledPath: string, zoneId: BuiltinCompiledZoneId): string;
-export declare function compiledSummariesPath(compiledPath: string): string;
-export declare function compiledKnowledgeEntitiesPath(compiledPath: string): string;
-export declare function compiledKnowledgeClaimsPath(compiledPath: string): string;
-export declare function compiledKnowledgeIndexesPath(compiledPath: string): string;
-export declare function compiledKnowledgeRootPath(compiledPath: string): string;
-export declare function compiledHomePath(compiledPath: string): string;
-export declare function ensureCompiledZoneTargets(compiledPath: string, schema: WorkflowCompiledSchema): void;
-export declare function buildCompiledSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeCompiledSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function readCompiledSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
+export * from "../packages/compiler/compiled-schema.js";