@interf/compiler 0.6.1 → 0.6.3

package/dist/lib/compiled-paths.js

@@ -1,106 +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 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(`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,2 +1 @@
-export declare function clearCompiledRuntimeDerivedArtifacts(compiledPath: string): void;
-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,72 +1,3 @@
-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));
-    }
-}
+// 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,31 +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 WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
-export declare function workflowSchemaFilePath(rootPath: string): string;
-export declare function resolveWorkflowSchemaPath(rootPath: string): string | null;
-export declare function workflowSchemaExists(rootPath: string): boolean;
-export declare function workflowSchemaRelativePath(): 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 buildWorkflowSchema(stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeWorkflowSchemaFile(rootPath: string, stages: WorkflowSchemaStageLike[], label?: string): WorkflowCompiledSchema;
-export declare function writeWorkflowSchemaDocument(rootPath: string, schema: WorkflowCompiledSchema): WorkflowCompiledSchema;
-export declare function readWorkflowSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
-export declare function readCompiledSchemaFile(rootPath: string): WorkflowCompiledSchema | null;
+export * from "../packages/compiler/compiled-schema.js";

package/dist/lib/compiled-schema.js

@@ -1,141 +1 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { warnInterf } from "./logger.js";
-import { readJsonFileUnchecked } from "./parse.js";
-import { BUILTIN_COMPILED_ZONE_IDS, listBuiltinCompiledZoneSpecs, requiredCompiledZoneOwners, } from "./builtin-compiled-workflow.js";
-import { WorkflowCompiledSchemaSchema, } from "./schema.js";
-export { BUILTIN_COMPILED_ZONE_IDS } from "./builtin-compiled-workflow.js";
-export const WORKFLOW_SCHEMA_FILE = "workflow.schema.json";
-const BUILTIN_COMPILED_ZONE_SPEC_BY_ID = new Map(listBuiltinCompiledZoneSpecs().map((zone) => [zone.id, zone]));
-export function workflowSchemaFilePath(rootPath) {
-    return join(rootPath, WORKFLOW_SCHEMA_FILE);
-}
-export function resolveWorkflowSchemaPath(rootPath) {
-    const path = workflowSchemaFilePath(rootPath);
-    return existsSync(path) ? path : null;
-}
-export function workflowSchemaExists(rootPath) {
-    return existsSync(workflowSchemaFilePath(rootPath));
-}
-export function workflowSchemaRelativePath() {
-    return `workflow/${WORKFLOW_SCHEMA_FILE}`;
-}
-export function listCompiledSchemaZones(schema) {
-    return [...schema.zones];
-}
-export function findCompiledSchemaZone(schema, zoneId) {
-    return schema.zones.find((zone) => zone.id === zoneId) ?? null;
-}
-export function compiledZoneAbsolutePath(compiledPath, zone) {
-    return join(compiledPath, zone.path);
-}
-export function compiledContractArtifactPath(zone) {
-    if (zone.kind === "file")
-        return zone.path;
-    return zone.path.endsWith("/") ? zone.path : `${zone.path}/`;
-}
-export function compiledContractArtifactPathsForZoneIds(schema, zoneIds) {
-    return zoneIds.map((zoneId) => {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            throw new Error(`Compiled schema is missing declared zone "${zoneId}".`);
-        }
-        return compiledContractArtifactPath(zone);
-    });
-}
-export function builtinCompiledZoneRelativePath(zoneId) {
-    const zone = BUILTIN_COMPILED_ZONE_SPEC_BY_ID.get(zoneId);
-    if (!zone) {
-        throw new Error(`Missing built-in compiled zone "${zoneId}".`);
-    }
-    return zone.path;
-}
-export function builtinCompiledZoneAbsolutePath(compiledPath, zoneId) {
-    return join(compiledPath, builtinCompiledZoneRelativePath(zoneId));
-}
-export function compiledSummariesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.SUMMARIES);
-}
-export function compiledKnowledgeEntitiesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_ENTITIES);
-}
-export function compiledKnowledgeClaimsPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_CLAIMS);
-}
-export function compiledKnowledgeIndexesPath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.KNOWLEDGE_INDEXES);
-}
-export function compiledKnowledgeRootPath(compiledPath) {
-    return dirname(compiledKnowledgeEntitiesPath(compiledPath));
-}
-export function compiledHomePath(compiledPath) {
-    return builtinCompiledZoneAbsolutePath(compiledPath, BUILTIN_COMPILED_ZONE_IDS.HOME);
-}
-export function ensureCompiledZoneTargets(compiledPath, schema) {
-    for (const zone of schema.zones) {
-        if (zone.kind === "directory" || zone.kind === "runtime") {
-            mkdirSync(compiledZoneAbsolutePath(compiledPath, zone), { recursive: true });
-            continue;
-        }
-        mkdirSync(dirname(compiledZoneAbsolutePath(compiledPath, zone)), { recursive: true });
-    }
-}
-function pushZone(zones, zone) {
-    if (zones.some((existing) => existing.path === zone.path))
-        return;
-    zones.push(zone);
-}
-function normalizeWorkflowSchema(schema) {
-    return {
-        ...schema,
-        kind: "workflow-schema",
-    };
-}
-export function buildWorkflowSchema(stages, label = "Workflow schema") {
-    const zones = [];
-    for (const zone of listBuiltinCompiledZoneSpecs()) {
-        pushZone(zones, {
-            id: zone.id,
-            role: zone.role,
-            path: zone.path,
-            kind: zone.kind,
-            required: zone.required,
-            owned_by: requiredCompiledZoneOwners(stages, zone.id),
-            description: zone.description,
-        });
-    }
-    return {
-        kind: "workflow-schema",
-        version: 1,
-        target_type: "compiled",
-        label,
-        zones,
-    };
-}
-export function writeWorkflowSchemaFile(rootPath, stages, label) {
-    const schema = buildWorkflowSchema(stages, label);
-    writeWorkflowSchemaDocument(rootPath, schema);
-    return schema;
-}
-export function writeWorkflowSchemaDocument(rootPath, schema) {
-    const normalized = normalizeWorkflowSchema(schema);
-    writeFileSync(workflowSchemaFilePath(rootPath), `${JSON.stringify(normalized, null, 2)}\n`);
-    return normalized;
-}
-export function readWorkflowSchemaFile(rootPath) {
-    const path = workflowSchemaFilePath(rootPath);
-    if (!existsSync(path))
-        return null;
-    const raw = readJsonFileUnchecked(path, "workflow schema");
-    if (raw === null)
-        return null;
-    const parsed = WorkflowCompiledSchemaSchema.safeParse(raw);
-    if (!parsed.success) {
-        warnInterf(`Warning: failed to validate workflow schema at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-        return null;
-    }
-    return normalizeWorkflowSchema(parsed.data);
-}
-export function readCompiledSchemaFile(rootPath) {
-    return readWorkflowSchemaFile(rootPath);
-}
+export * from "../packages/compiler/compiled-schema.js";

package/dist/lib/execution-profile.d.ts

@@ -1,17 +1 @@
-import type { Argv } from "yargs";
-import type { Agent } from "./agents.js";
-import type { WorkflowExecutionProfile } from "./executors.js";
-type AgentLike = Pick<Agent, "name"> | string | null | undefined;
-export declare function addExecutionProfileOptions<T extends Argv>(yargs: T): T;
-type ExecutionProfileArgSource = Record<string, unknown> & {
-    model?: unknown;
-    profile?: unknown;
-    effort?: unknown;
-    timeoutMs?: unknown;
-    "timeout-ms"?: unknown;
-};
-export declare function executionProfileFromArgv(argv: ExecutionProfileArgSource): WorkflowExecutionProfile;
-export declare function applyInternalAcceptanceExecutionProfileDefaults(agent: AgentLike, overrides?: WorkflowExecutionProfile): WorkflowExecutionProfile;
-export declare function hasWorkflowExecutionProfile(profile: WorkflowExecutionProfile | null | undefined): boolean;
-export declare function formatWorkflowExecutionProfile(profile: WorkflowExecutionProfile | null | undefined): string | null;
-export {};
+export * from "../packages/agents/lib/execution-profile.js";

package/dist/lib/execution-profile.js

@@ -1,84 +1 @@
-const INTERNAL_ACCEPTANCE_DEFAULTS = {
-    "claude-code": {
-        model: "claude-sonnet-4-6",
-        effort: "low",
-    },
-    codex: {
-        model: "gpt-5.4-mini",
-        effort: "low",
-    },
-};
-function readAgentName(agent) {
-    if (!agent)
-        return null;
-    return typeof agent === "string" ? agent : agent.name;
-}
-function normalizeOptionalString(value) {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function normalizeOptionalTimeout(value) {
-    if (value === undefined || value === null || value === "")
-        return null;
-    const parsed = typeof value === "number" ? value : Number.parseInt(String(value), 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`Invalid timeout: ${String(value)}`);
-    }
-    return parsed;
-}
-export function addExecutionProfileOptions(yargs) {
-    return yargs
-        .option("model", {
-        type: "string",
-        describe: "Override the local executor model for this run",
-    })
-        .option("profile", {
-        type: "string",
-        describe: "Executor-specific profile override for this run",
-    })
-        .option("effort", {
-        type: "string",
-        describe: "Override the model reasoning effort for this run",
-    })
-        .option("timeout-ms", {
-        type: "number",
-        describe: "Interrupt the local executor after this much inactivity",
-    });
-}
-export function executionProfileFromArgv(argv) {
-    return {
-        model: normalizeOptionalString(argv.model),
-        profile: normalizeOptionalString(argv.profile),
-        effort: normalizeOptionalString(argv.effort),
-        timeoutMs: normalizeOptionalTimeout(argv.timeoutMs ?? argv["timeout-ms"]),
-    };
-}
-export function applyInternalAcceptanceExecutionProfileDefaults(agent, overrides = {}) {
-    const defaults = INTERNAL_ACCEPTANCE_DEFAULTS[readAgentName(agent) ?? ""];
-    const profile = overrides.profile ?? null;
-    const explicitEffort = overrides.effort ?? null;
-    return {
-        model: overrides.model ?? defaults?.model ?? null,
-        profile,
-        effort: explicitEffort ?? (profile ? null : defaults?.effort ?? null),
-        timeoutMs: overrides.timeoutMs ?? null,
-    };
-}
-export function hasWorkflowExecutionProfile(profile) {
-    return Boolean(profile?.model ||
-        profile?.profile ||
-        profile?.effort ||
-        profile?.timeoutMs);
-}
-export function formatWorkflowExecutionProfile(profile) {
-    if (!hasWorkflowExecutionProfile(profile))
-        return null;
-    return JSON.stringify({
-        ...(profile?.model ? { model: profile.model } : {}),
-        ...(profile?.profile ? { profile: profile.profile } : {}),
-        ...(profile?.effort ? { effort: profile.effort } : {}),
-        ...(profile?.timeoutMs ? { timeout_ms: profile.timeoutMs } : {}),
-    });
-}
+export * from "../packages/agents/lib/execution-profile.js";

package/dist/lib/executors.d.ts

@@ -1,32 +1 @@
-import type { Agent } from "./agents.js";
-import type { RuntimeExecutorInfo } from "./schema.js";
-export type WorkflowExecutorKind = "local-agent" | "connected-provider" | "managed";
-export interface WorkflowExecutionProfile {
-    model?: string | null;
-    effort?: string | null;
-    profile?: string | null;
-    timeoutMs?: number | null;
-}
-export interface WorkflowExecuteOptions {
-    eventLogPath?: string | null;
-    statusLogPath?: string | null;
-    completionCheck?: (() => boolean) | null;
-}
-export interface WorkflowExecutor {
-    kind: WorkflowExecutorKind;
-    name: string;
-    displayName: string;
-    command?: string | null;
-    executionProfile?: WorkflowExecutionProfile;
-    execute(rootPath: string, prompt: string, options?: WorkflowExecuteOptions): Promise<number>;
-}
-export type { RuntimeExecutorInfo } from "./schema.js";
-export declare function buildRuntimeExecutorInfo(executor: WorkflowExecutor): RuntimeExecutorInfo;
-export declare function createLocalAgentExecutor(agent: Agent, executionProfile?: WorkflowExecutionProfile): WorkflowExecutor;
-export declare function resolveLocalExecutor(options?: {
-    preflight?: boolean;
-    executionProfile?: WorkflowExecutionProfile;
-}): {
-    executor: WorkflowExecutor | null;
-    error?: string;
-};
+export * from "../packages/agents/lib/executors.js";