@interf/compiler 0.6.3 → 0.6.5

package/dist/packages/compiler/reset.js

@@ -0,0 +1,72 @@
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { initializeCompiledRuntimeState } from "./state.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } 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",
+    "raw-snapshot.json",
+    "stage-contract.json",
+];
+const PRESERVED_COMPILED_ROOTS = new Set([
+    ".agents",
+    ".claude",
+    ".codex",
+    ".cursor",
+    ".gitignore",
+    ".interf",
+    ".interfignore",
+    "AGENTS.md",
+    "CLAUDE.md",
+]);
+export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
+    const runtimeRoot = compiledRuntimeRoot(compiledPath);
+    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
+        removeIfExists(join(runtimeRoot, entry));
+    }
+    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
+}
+function activeCompiledInputRoots(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const roots = new Set();
+    for (const zone of schema?.zones ?? []) {
+        if (zone.role !== "input")
+            continue;
+        const root = zone.path.split("/")[0]?.trim();
+        if (root)
+            roots.add(root);
+    }
+    return roots;
+}
+function resetCompiledGeneratedOutputs(compiledPath) {
+    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
+    for (const entry of readdirSync(compiledPath)) {
+        if (PRESERVED_COMPILED_ROOTS.has(entry))
+            continue;
+        if (preservedInputRoots.has(entry))
+            continue;
+        removeIfExists(join(compiledPath, entry));
+    }
+}
+export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
+    resetCompiledGeneratedOutputs(compiledPath);
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
+    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));
+    }
+}

package/dist/packages/compiler/runtime-acceptance.js

@@ -1,11 +1,11 @@
 import { existsSync, } from "node:fs";
 import { join } from "node:path";
-import { listFilesRecursive } from "../../lib/filesystem.js";
-import { readJsonFileWithSchema } from "../../lib/parse.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
+import { readJsonFileWithSchema } from "../shared/parse.js";
 import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { RuntimeStageContractSchema, } from "./lib/schema.js";
 import { stageContractPath } from "./runtime-paths.js";
-import { workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { loadState } from "./state-io.js";
 import { countBrokenWikilinks, isOutputMarkdownFile, safeReadText, validateSynthFiles } from "./validate.js";
 function toFiniteNumber(value) {

package/dist/packages/compiler/runtime-contracts.js

@@ -28,7 +28,7 @@ export function buildRuntimeStageContract(options) {
             notes: [
                 `This is the "${options.stageLabel}" stage for the compiled context "${options.compiledName}".`,
                 "The workflow package is the authoritative method layer for this run.",
-                `Use \`workflow/${WORKFLOW_SCHEMA_FILE}\` as the deterministic zone-contract reference for this compiled context.`,
+                `Use \`workflow/${WORKFLOW_SCHEMA_FILE}\` as the deterministic context-interface reference for this compiled context.`,
                 "Honor the declared read and write artifacts instead of inventing a parallel workflow.",
                 "Only create or update files that fall under the declared write targets for this stage.",
                 "Interf writes `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",

package/dist/packages/compiler/runtime-paths.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { compiledRuntimeArchivedStageContractPath, compiledRuntimeLogsRoot, compiledRuntimeRunHistoryPath, compiledRuntimeRunPath, compiledRuntimeStageContractPath, } from "../project-model/compiled-paths.js";
+import { compiledRuntimeArchivedStageContractPath, compiledRuntimeLogsRoot, compiledRuntimeRunHistoryPath, compiledRuntimeRunPath, compiledRuntimeStageContractPath, } from "./compiled-paths.js";
 export function runPath(dirPath) {
     return compiledRuntimeRunPath(dirPath);
 }

package/dist/packages/compiler/runtime-reconcile.js

@@ -1,12 +1,12 @@
 import { existsSync, readFileSync, statSync, writeFileSync, } from "node:fs";
 import { extname, join, relative } from "node:path";
-import { listFilesRecursive } from "../../lib/filesystem.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
 import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { parseJsonFrontmatter } from "../../lib/parse.js";
+import { parseJsonFrontmatter } from "../shared/parse.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { initCompiledState, loadState, refreshCompiledArtifacts, saveState, } from "./state.js";
 import { compiledInventoryFromEntries } from "./runtime-inventory.js";
-import { compiledRuntimeRoot } from "../project-model/compiled-paths.js";
+import { compiledRuntimeRoot } from "./compiled-paths.js";
 import { extractSynthAbstract, isOutputMarkdownFile } from "./validate.js";
 function readActiveRunStartedAtMs(dirPath) {
     const run = loadRuntimeRun(dirPath);

package/dist/packages/compiler/runtime-runs.js

@@ -1,12 +1,12 @@
 import { appendFileSync, mkdirSync, existsSync, readFileSync, writeFileSync, } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import chalk from "chalk";
-import { countFilesRecursive } from "../../lib/filesystem.js";
+import { countFilesRecursive } from "../shared/filesystem.js";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
 import { RuntimeRunSchema, } from "./lib/schema.js";
 import { getWorkflowStageDefinition, getWorkflowStagePosition, getWorkflowStages, } from "../workflow-package/workflow-definitions.js";
 import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
-import { warnInterf } from "../../lib/logger.js";
+import { warnInterf } from "../shared/logger.js";
 export function loadRuntimeRun(dirPath) {
     const path = runPath(dirPath);
     if (!existsSync(path))

package/dist/packages/compiler/state-health.js

@@ -1,14 +1,14 @@
 import { basename, join } from "node:path";
 import { existsSync } from "node:fs";
 import { readInterfConfig, resolveSourceFolderPath, } from "../project-model/interf-detect.js";
-import { discoverSourceFiles } from "../../lib/discovery.js";
+import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
 import { validateCompiled, validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "../workflow-package/workflow-definitions.js";
-import { listFilesRecursive } from "../../lib/filesystem.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = join(compiledPath, zonePath);
     if (!existsSync(absolutePath))

package/dist/packages/compiler/state-io.js

@@ -1,10 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { warnInterf } from "../../lib/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../lib/parse.js";
+import { warnInterf } from "../shared/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
 import { CompiledHealthSchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./lib/schema.js";
 import { emptyCompiledInventory, } from "./runtime-inventory.js";
 import { healthPath, rawSnapshotPath, statePath, viewSpecPath } from "./state-paths.js";
-import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "../project-model/compiled-paths.js";
+import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
 export function loadState(dirPath) {
     const path = statePath(dirPath);
     if (!existsSync(path))

package/dist/packages/compiler/state-paths.js

@@ -1,4 +1,4 @@
-import { compiledRawSnapshotMetadataPath, compiledRuntimeHealthPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "../project-model/compiled-paths.js";
+import { compiledRawSnapshotMetadataPath, compiledRuntimeHealthPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "./compiled-paths.js";
 export function statePath(dirPath) {
     return compiledRuntimeStatePath(dirPath);
 }

package/dist/packages/compiler/state-view.js

@@ -1,10 +1,10 @@
 import { basename, relative } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
-import { discoverSourceFiles } from "../../lib/discovery.js";
+import { discoverSourceFiles } from "./discovery.js";
 import { readInterfConfig, resolveSourceFolderPath } from "../project-model/interf-detect.js";
 import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { rawSnapshotPath } from "./state-paths.js";
-import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "../workflow-package/workflow-definitions.js";
 export function ensureCompiledViewSpec(dirPath) {

package/dist/packages/compiler/validate-compiled.js

@@ -1,14 +1,14 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { discoverSourceFiles } from "../../lib/discovery.js";
+import { discoverSourceFiles } from "./discovery.js";
 import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
 import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
-import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
+import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
 import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
 import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
-import { listFilesRecursive } from "../../lib/filesystem.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
 function workflowSchemaPresent(dirPath) {
     return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
 }

package/dist/packages/compiler/validate.js

@@ -2,11 +2,11 @@ import { existsSync, readFileSync, statSync, } from "node:fs";
 import { basename, extname, join } from "node:path";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { compiledKnowledgeRootPath } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "../project-model/compiled-paths.js";
-import { listFilesRecursive } from "../../lib/filesystem.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { listFilesRecursive } from "../shared/filesystem.js";
 import { readInterfConfig } from "../project-model/interf-detect.js";
-import { parseJsonFrontmatter } from "../../lib/parse.js";
-import { compiledInterfConfigPath } from "../project-model/compiled-paths.js";
+import { parseJsonFrontmatter } from "../shared/parse.js";
+import { compiledInterfConfigPath } from "./compiled-paths.js";
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
 export function readCompiledConfig(dirPath) {

package/dist/packages/project-model/compiled-paths.d.ts

@@ -1,40 +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 compiledRuntimeArchivedStageContractPath(compiledPath: string, runId: 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 "../compiler/compiled-paths.js";

package/dist/packages/project-model/compiled-paths.js

@@ -1,106 +1 @@
-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 compiledRuntimeArchivedStageContractPath(compiledPath, runId) {
-    return join(compiledRuntimeLogsRoot(compiledPath), `${runId}.stage-contract.json`);
-}
-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(`Context folder 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("/") : ".";
-}
+export * from "../compiler/compiled-paths.js";

package/dist/packages/project-model/compiled-raw.d.ts

@@ -1,49 +1 @@
-import type { InterfConfig } from "./lib/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 "../compiler/raw-snapshot.js";

package/dist/packages/project-model/compiled-raw.js

@@ -1,102 +1 @@
-import { cpSync, existsSync, linkSync, mkdirSync, rmSync, statSync, } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-import { listFilesRecursive } from "../../lib/filesystem.js";
-import { discoverSourceFiles } from "../../lib/discovery.js";
-import { readInterfConfig, resolveSourceInputPath, } from "./interf-detect.js";
-import { saveCompiledInterfConfig } from "./source-config.js";
-import { defaultControlPathForCompiled, } from "./compiled-paths.js";
-import { assertPathWithinRoot } from "../../lib/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,
-    };
-}
+export * from "../compiler/raw-snapshot.js";

package/dist/packages/project-model/compiled-reset.d.ts

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

package/dist/packages/project-model/compiled-reset.js

@@ -1,72 +1 @@
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { readCompiledSchemaFile, } from "../compiler/compiled-schema.js";
-import { initializeCompiledRuntimeState, } from "../compiler/state.js";
-import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } 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",
-    "raw-snapshot.json",
-    "stage-contract.json",
-];
-const PRESERVED_COMPILED_ROOTS = new Set([
-    ".agents",
-    ".claude",
-    ".codex",
-    ".cursor",
-    ".gitignore",
-    ".interf",
-    ".interfignore",
-    "AGENTS.md",
-    "CLAUDE.md",
-]);
-export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
-    const runtimeRoot = compiledRuntimeRoot(compiledPath);
-    for (const entry of COMPILE_RUNTIME_RESET_ENTRIES) {
-        removeIfExists(join(runtimeRoot, entry));
-    }
-    removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
-}
-function activeCompiledInputRoots(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
-    const roots = new Set();
-    for (const zone of schema?.zones ?? []) {
-        if (zone.role !== "input")
-            continue;
-        const root = zone.path.split("/")[0]?.trim();
-        if (root)
-            roots.add(root);
-    }
-    return roots;
-}
-function resetCompiledGeneratedOutputs(compiledPath) {
-    const preservedInputRoots = activeCompiledInputRoots(compiledPath);
-    for (const entry of readdirSync(compiledPath)) {
-        if (PRESERVED_COMPILED_ROOTS.has(entry))
-            continue;
-        if (preservedInputRoots.has(entry))
-            continue;
-        removeIfExists(join(compiledPath, entry));
-    }
-}
-export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
-    resetCompiledGeneratedOutputs(compiledPath);
-    clearCompiledRuntimeDerivedArtifacts(compiledPath);
-    initializeCompiledRuntimeState(compiledPath);
-    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));
-    }
-}
+export * from "../compiler/reset.js";

package/dist/packages/project-model/interf-bootstrap.d.ts

@@ -1,3 +1 @@
-import { renderClaudeBootstrap } from "../agents/lib/shells.js";
-export { renderClaudeBootstrap };
-export declare function refreshCompiledBootstrapGuidance(dirPath: string): boolean;
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";

package/dist/packages/project-model/interf-bootstrap.js

@@ -1,18 +1 @@
-import { basename } from "node:path";
-import { readInterfConfig } from "./interf-detect.js";
-import { projectCompiledQueryShell, renderClaudeBootstrap } from "../agents/lib/shells.js";
-export { renderClaudeBootstrap };
-export function refreshCompiledBootstrapGuidance(dirPath) {
-    const config = readInterfConfig(dirPath);
-    if (!config)
-        return false;
-    const compiledName = config.name ?? basename(dirPath);
-    const workflowId = config.workflow ?? "interf";
-    const workflowOriginSelected = config.workflow_origin?.selected ?? workflowId;
-    const workflowLocalDraft = config.workflow_origin?.local_draft === true;
-    const about = typeof config.about === "string" && config.about.length > 0 ? config.about : undefined;
-    return projectCompiledQueryShell(dirPath, compiledName, workflowId, about, {
-        workflowOriginSelected,
-        workflowLocalDraft,
-    });
-}
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "../agents/lib/compiled-bootstrap.js";