@interf/compiler 0.5.1 → 0.6.3

package/dist/lib/workflow-helpers.js

@@ -1,167 +1 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, relative, sep } from "node:path";
-import { listFilesRecursive } from "./filesystem.js";
-import { isMarkdownFile } from "./util.js";
-import { getCompiledWorkflow, } from "./workflow-definitions.js";
-import { parseJsonFrontmatter } from "./parse.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-const LOCAL_SKILL_READ_LIMIT = 50;
-export function workflowQueryDirectory() {
-    return "workflow/use/query";
-}
-export function workflowImproveDirectory() {
-    return "workflow/improve";
-}
-export function workflowCompileStageDirectory(stageDir) {
-    return `workflow/compile/stages/${stageDir}`;
-}
-export function emptyLocalSkillContractExtension() {
-    return {
-        reads: [],
-        count: 0,
-        notes: [],
-        localMode: null,
-        effectiveMode: "builtin",
-        modeSources: [],
-    };
-}
-function readLocalInstructionMode(filePath) {
-    try {
-        const parsed = parseJsonFrontmatter(readFileSync(filePath, "utf8"));
-        const mode = parsed?.frontmatter.mode;
-        return mode === "extend" || mode === "override" ? mode : null;
-    }
-    catch {
-        return null;
-    }
-}
-function collectLocalSkillDocs(rootPath, directories) {
-    return collectLocalSkillDocsRelativeTo(rootPath, rootPath, directories);
-}
-function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
-    const docs = new Map();
-    const workflowRoot = workflowPackagePathForCompiled(rootPath);
-    const rootReadme = join(workflowRoot, "README.md");
-    if (existsSync(rootReadme)) {
-        const read = projectWorkflowReadPath(rootPath, relativeToPath, rootReadme);
-        docs.set(read, {
-            read,
-            absolutePath: rootReadme,
-            mode: readLocalInstructionMode(rootReadme),
-        });
-    }
-    for (const directory of directories) {
-        const absoluteDirectory = resolveAuthoringDirectory(rootPath, directory);
-        for (const filePath of listFilesRecursive(absoluteDirectory, isMarkdownFile)) {
-            const read = projectWorkflowReadPath(rootPath, relativeToPath, filePath);
-            docs.set(read, {
-                read,
-                absolutePath: filePath,
-                mode: readLocalInstructionMode(filePath),
-            });
-        }
-    }
-    return Array.from(docs.values())
-        .sort((a, b) => a.read.localeCompare(b.read))
-        .slice(0, LOCAL_SKILL_READ_LIMIT);
-}
-function resolveAuthoringDirectory(rootPath, directory) {
-    if (directory === "workflow") {
-        return workflowPackagePathForCompiled(rootPath);
-    }
-    if (directory.startsWith(`workflow${sep}`) || directory.startsWith("workflow/")) {
-        const relativeWorkflowPath = directory.replace(/^workflow[\\/]/, "");
-        return join(workflowPackagePathForCompiled(rootPath), relativeWorkflowPath);
-    }
-    return join(rootPath, directory);
-}
-function projectWorkflowReadPath(rootPath, relativeToPath, absolutePath) {
-    const workflowRoot = workflowPackagePathForCompiled(rootPath);
-    const normalizedWorkflowRoot = `${workflowRoot}${sep}`;
-    if (absolutePath === workflowRoot || absolutePath.startsWith(normalizedWorkflowRoot)) {
-        const relativeWorkflowPath = relative(workflowRoot, absolutePath);
-        return relative(relativeToPath, join(rootPath, "workflow", relativeWorkflowPath));
-    }
-    return relative(relativeToPath, absolutePath);
-}
-export function buildLocalSkillContractExtension(rootPath, directories, purpose) {
-    const docs = collectLocalSkillDocs(rootPath, directories);
-    return buildContractExtensionFromDocs(docs, directories, purpose);
-}
-export function buildLocalSkillContractExtensionRelativeTo(rootPath, relativeToPath, directories, purpose) {
-    const docs = collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories);
-    return buildContractExtensionFromDocs(docs, directories, purpose);
-}
-function buildContractExtensionFromDocs(docs, directories, purpose) {
-    const reads = docs.map((doc) => doc.read);
-    const modeSources = docs.filter((doc) => doc.mode !== null).map((doc) => doc.read);
-    const localMode = docs.some((doc) => doc.mode === "override")
-        ? "override"
-        : docs.some((doc) => doc.mode === "extend")
-            ? "extend"
-            : null;
-    if (docs.length === 0) {
-        return emptyLocalSkillContractExtension();
-    }
-    const readNotice = directories.length > 0
-        ? `Read any local instruction docs listed under ${directories.join(", ")} before executing the core stage.`
-        : "Read any local instruction docs listed by the stage contract before executing the core stage.";
-    return {
-        reads,
-        count: reads.length,
-        notes: [
-            readNotice,
-            localMode === "override"
-                ? `${purpose} One or more local docs declare \`mode: override\`, so their workflow instructions replace Interf's bundled stage instructions for this run. They still do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`
-                : `${purpose} These local workflow docs can refine the stage, but they do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`,
-        ],
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
-export function mergeLocalSkillContractExtensions(extensions) {
-    const reads = Array.from(new Set(extensions.flatMap((extension) => extension.reads)));
-    const notes = Array.from(new Set(extensions.flatMap((extension) => extension.notes)));
-    const modeSources = Array.from(new Set(extensions.flatMap((extension) => extension.modeSources)));
-    const localMode = extensions.some((extension) => extension.localMode === "override")
-        ? "override"
-        : extensions.some((extension) => extension.localMode === "extend")
-            ? "extend"
-            : null;
-    return {
-        reads,
-        count: reads.length,
-        notes,
-        localMode,
-        effectiveMode: localMode ?? "builtin",
-        modeSources,
-    };
-}
-export function buildStageInstructions(stageSkillDir, localSkills) {
-    return {
-        stage_skill_dir: stageSkillDir,
-        effective_mode: localSkills.effectiveMode,
-        local_mode: localSkills.localMode,
-        local_docs: localSkills.reads,
-        mode_sources: localSkills.modeSources,
-    };
-}
-export function reportLine(reporter, message) {
-    reporter?.line?.(message);
-}
-export function reportBlankLine(reporter) {
-    reporter?.blankLine?.();
-}
-export function reportValidationFailure(reporter, summary, errors = []) {
-    reportLine(reporter, summary);
-    for (const error of errors) {
-        reportLine(reporter, `- ${error}`);
-    }
-}
-export function resolveStageAcceptance(workflowId, stageId, sourcePath) {
-    return getCompiledWorkflow(workflowId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
-}
-export function validateStageOutcome(_dirPath, validation) {
-    return validation;
-}
+export * from "../packages/workflow-package/workflow-helpers.js";

package/dist/lib/workflow-improvement.d.ts

@@ -1,22 +1 @@
-import type { WorkflowExecutor } from "./executors.js";
-import { type WorkflowValidationResult } from "./local-workflows.js";
-import type { SourceDatasetConfig, WorkflowImprovementLoopSummary } from "./schema.js";
-export interface WorkflowImprovementRunResult {
-    status: "updated" | "no-change" | "invalid" | "executor-failed";
-    changed: boolean;
-    validation: WorkflowValidationResult | null;
-    summary: string;
-    shellPath: string;
-    loopRootPath: string;
-}
-export declare function runWorkflowImprovementLoop(options: {
-    executor: WorkflowExecutor;
-    compiledPath: string;
-    workflowId: string;
-    compiledConfig: Pick<SourceDatasetConfig, "checks">;
-    runId: string;
-    loopIndex: number;
-    maxLoops: number;
-    maxAttempts: number;
-    previousVariations: WorkflowImprovementLoopSummary[];
-}): Promise<WorkflowImprovementRunResult>;
+export * from "../packages/workflow-authoring/workflow-improvement.js";

package/dist/lib/workflow-improvement.js

@@ -1,396 +1 @@
-import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
-import { join, relative } from "node:path";
-import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from "./agent-shells.js";
-import { readInterfConfig } from "./interf.js";
-import { validateWorkflowPackage } from "./local-workflows.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { saveCompiledInterfConfig } from "./source-config.js";
-import { WorkflowImprovementRunLedgerSchema, } from "./schema.js";
-import { resolveWorkflowImprovementReviewPaths } from "./workflow-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, workflowImprovementRunRoot, workflowPackagePathForCompiled, } from "./compiled-paths.js";
-function copyDirectory(sourcePath, targetPath) {
-    rmSync(targetPath, { recursive: true, force: true });
-    mkdirSync(targetPath, { recursive: true });
-    cpSync(sourcePath, targetPath, { recursive: true });
-}
-function listFileSnapshot(dirPath) {
-    const snapshot = new Map();
-    if (!existsSync(dirPath))
-        return snapshot;
-    const collect = (currentPath) => {
-        for (const entry of readdirSync(currentPath)) {
-            const fullPath = join(currentPath, entry);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                collect(fullPath);
-                continue;
-            }
-            if (!stat.isFile())
-                continue;
-            snapshot.set(relative(dirPath, fullPath), readFileSync(fullPath, "utf8"));
-        }
-    };
-    collect(dirPath);
-    return snapshot;
-}
-function directoriesMatch(leftPath, rightPath) {
-    const left = listFileSnapshot(leftPath);
-    const right = listFileSnapshot(rightPath);
-    if (left.size !== right.size)
-        return false;
-    for (const [relativePath, content] of left.entries()) {
-        if (right.get(relativePath) !== content) {
-            return false;
-        }
-    }
-    return true;
-}
-function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
-    if (!absolutePath)
-        return null;
-    const normalizedSourceRoot = `${sourceRoot}/`;
-    if (absolutePath !== sourceRoot && !absolutePath.startsWith(normalizedSourceRoot)) {
-        return null;
-    }
-    const relativePath = relative(sourceRoot, absolutePath);
-    return join(shellRoot, relativePath);
-}
-function mapLoopSummaryForShell(summary, compiledPath) {
-    const shellTestRunsRoot = "artifacts/test-runs";
-    const shellTestSandboxesRoot = "artifacts/test-sandboxes";
-    return {
-        ...summary,
-        test_run_path: toShellArtifactPath(summary.test_run_path, targetTestRunsRootForCompiled(compiledPath), shellTestRunsRoot) ?? summary.test_run_path ?? null,
-        test_sandbox_path: toShellArtifactPath(summary.test_sandbox_path, targetTestSandboxesRootForCompiled(compiledPath), shellTestSandboxesRoot) ?? summary.test_sandbox_path ?? null,
-    };
-}
-function buildLoopContext(options) {
-    const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.compiledPath));
-    const latestFailure = previousVariations.at(-1) ?? null;
-    return {
-        kind: "interf-workflow-improvement-loop",
-        version: 1,
-        generated_at: new Date().toISOString(),
-        target_name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-        workflow_id: options.workflowId,
-        loop_index: options.loopIndex,
-        max_loops: options.maxLoops,
-        max_attempts: options.maxAttempts,
-        review_paths: resolveWorkflowImprovementReviewPaths(options.compiledPath),
-        truth_checks: {
-            count: options.compiledConfig.checks.length,
-            questions: options.compiledConfig.checks.map((check, index) => ({
-                id: check.id ?? `check-${index + 1}`,
-                question: check.question,
-            })),
-        },
-        previous_variations: previousVariations,
-        latest_failure: latestFailure,
-    };
-}
-function buildWorkflowImprovementPrompt() {
-    return [
-        "This is an automated Interf Compiler workflow-improvement run, not an open-ended chat session.",
-        "The user already invoked this through `interf compile` with self-improving loops enabled. Execute it now.",
-        "Read `runtime/loop-context.json` first.",
-        "Then read `workflow/README.md`, `workflow/workflow.json`, `workflow/compiled.schema.json`, and `workflow/improve/SKILL.md` if it exists.",
-        "Review preserved evidence from earlier failures under `artifacts/` before you edit the workflow.",
-        "Treat `workflow/improve/SKILL.md` as guidance for how to improve the workflow, not as the default file to edit.",
-        "Prefer editing the stage docs, workflow contract, or schema ownership that actually change compiled outputs.",
-        "Edit only files under `workflow/`.",
-        "Do not edit truth checks, test specs, raw dataset files, or generated compiled outputs.",
-        "Keep the workflow valid for the current compiler API and compiled schema.",
-        "Prefer small, defensible changes to workflow docs, stage docs, stage policies, or schema ownership over random churn.",
-        "Do not narrate plans or ask follow-up questions.",
-        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "As soon as the workflow edits are complete, stop.",
-    ].join("\n");
-}
-function updateCompiledWorkflowOrigin(options) {
-    const current = readInterfConfig(options.compiledPath);
-    if (!current)
-        return;
-    const nextConfig = {
-        ...current,
-        workflow: current.workflow ?? options.selectedWorkflowId,
-        workflow_origin: {
-            selected: options.selectedWorkflowId,
-            ...(options.localDraft ? { local_draft: true } : {}),
-        },
-    };
-    saveCompiledInterfConfig(options.compiledPath, nextConfig);
-}
-function workflowImprovementRunLedgerPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "run.json");
-}
-function workflowImprovementLoopHistoryPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
-}
-function workflowImprovementLoopRecordPath(loopRootPath) {
-    return join(loopRootPath, "loop.json");
-}
-function readWorkflowImprovementRunLedger(compiledPath, runId) {
-    const ledgerPath = workflowImprovementRunLedgerPath(compiledPath, runId);
-    if (!existsSync(ledgerPath))
-        return null;
-    return readJsonFileWithSchema(ledgerPath, "workflow improvement run ledger", WorkflowImprovementRunLedgerSchema);
-}
-function writeWorkflowImprovementRunLedger(compiledPath, runId, record, options) {
-    const runRoot = workflowImprovementRunRoot(compiledPath, runId);
-    mkdirSync(runRoot, { recursive: true });
-    const existing = readWorkflowImprovementRunLedger(compiledPath, runId);
-    const generatedAt = existing?.generated_at ?? new Date().toISOString();
-    const ledger = {
-        kind: "interf-workflow-improvement-run",
-        version: 1,
-        generated_at: generatedAt,
-        updated_at: new Date().toISOString(),
-        run_id: runId,
-        target_name: options.targetName,
-        workflow_id: options.workflowId,
-        max_loops: options.maxLoops,
-        max_attempts: options.maxAttempts,
-        loops: [...(existing?.loops ?? []), record],
-    };
-    writeFileSync(workflowImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
-    writeFileSync(workflowImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
-    appendFileSync(workflowImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
-}
-function buildWorkflowImprovementLoopRecord(options) {
-    return {
-        kind: "interf-workflow-improvement-loop-record",
-        version: 1,
-        recorded_at: new Date().toISOString(),
-        run_id: options.runId,
-        loop_index: options.loopIndex,
-        target_name: options.targetName,
-        workflow_id: options.workflowId,
-        result: options.result,
-        changed: options.changed,
-        applied: options.result === "updated",
-        summary: options.summary,
-        shell_path: options.shellPath,
-        loop_root_path: options.loopRootPath,
-        context_path: join(options.shellPath, "runtime", "loop-context.json"),
-        workflow_before_path: options.workflowBeforePath,
-        workflow_after_path: options.workflowAfterPath,
-        prompt_log_path: options.promptLogPath,
-        event_log_path: options.eventLogPath,
-        status_log_path: options.statusLogPath,
-        preserved_shell_manifest_path: options.preservedShellManifestPath,
-        validation: options.validation,
-    };
-}
-export async function runWorkflowImprovementLoop(options) {
-    const compiledName = readInterfConfig(options.compiledPath)?.name ?? "compiled";
-    const context = buildLoopContext(options);
-    const shell = createWorkflowImprovementShell({
-        compiledPath: options.compiledPath,
-        compiledName,
-        workflowId: options.workflowId,
-        runId: options.runId,
-        loopIndex: options.loopIndex,
-        context,
-    });
-    const workflowRoot = workflowPackagePathForCompiled(options.compiledPath);
-    copyDirectory(workflowRoot, shell.workflowBeforePath);
-    const prompt = buildWorkflowImprovementPrompt();
-    writeFileSync(shell.promptLogPath, `${prompt}\n`);
-    let code = 1;
-    let executeError = null;
-    try {
-        code = await options.executor.execute(shell.rootPath, prompt, {
-            eventLogPath: shell.eventLogPath,
-            statusLogPath: shell.statusLogPath,
-        });
-    }
-    catch (error) {
-        executeError = error instanceof Error ? error.message : String(error);
-    }
-    copyDirectory(workflowRoot, shell.workflowAfterPath);
-    const preservedShellManifestPath = freezeWorkflowImprovementShell(shell.rootPath);
-    const changed = !directoriesMatch(shell.workflowBeforePath, shell.workflowAfterPath);
-    if (executeError) {
-        copyDirectory(shell.workflowBeforePath, workflowRoot);
-        const summary = `Workflow improver failed before completing: ${executeError}`;
-        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            runId: options.runId,
-            loopIndex: options.loopIndex,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-            workflowBeforePath: shell.workflowBeforePath,
-            workflowAfterPath: shell.workflowAfterPath,
-            promptLogPath: shell.promptLogPath,
-            eventLogPath: shell.eventLogPath,
-            statusLogPath: shell.statusLogPath,
-            preservedShellManifestPath,
-            changed,
-            validation: null,
-            result: "executor-failed",
-            summary,
-        }), {
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            maxLoops: options.maxLoops,
-            maxAttempts: options.maxAttempts,
-        });
-        return {
-            status: "executor-failed",
-            changed,
-            validation: null,
-            summary,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-        };
-    }
-    if (code !== 0) {
-        copyDirectory(shell.workflowBeforePath, workflowRoot);
-        const summary = `Workflow improver exited with code ${code}.`;
-        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            runId: options.runId,
-            loopIndex: options.loopIndex,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-            workflowBeforePath: shell.workflowBeforePath,
-            workflowAfterPath: shell.workflowAfterPath,
-            promptLogPath: shell.promptLogPath,
-            eventLogPath: shell.eventLogPath,
-            statusLogPath: shell.statusLogPath,
-            preservedShellManifestPath,
-            changed,
-            validation: null,
-            result: "executor-failed",
-            summary,
-        }), {
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            maxLoops: options.maxLoops,
-            maxAttempts: options.maxAttempts,
-        });
-        return {
-            status: "executor-failed",
-            changed,
-            validation: null,
-            summary,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-        };
-    }
-    if (!changed) {
-        const validation = validateWorkflowPackage(workflowRoot);
-        const result = validation.ok ? "no-change" : "invalid";
-        if (!validation.ok) {
-            copyDirectory(shell.workflowBeforePath, workflowRoot);
-        }
-        const summary = validation.ok
-            ? "Workflow improver made no workflow edits."
-            : `Workflow variation is invalid without any workflow edits: ${validation.summary}`;
-        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            runId: options.runId,
-            loopIndex: options.loopIndex,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-            workflowBeforePath: shell.workflowBeforePath,
-            workflowAfterPath: shell.workflowAfterPath,
-            promptLogPath: shell.promptLogPath,
-            eventLogPath: shell.eventLogPath,
-            statusLogPath: shell.statusLogPath,
-            preservedShellManifestPath,
-            changed: false,
-            validation,
-            result,
-            summary,
-        }), {
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            maxLoops: options.maxLoops,
-            maxAttempts: options.maxAttempts,
-        });
-        return {
-            status: result,
-            changed: false,
-            validation,
-            summary,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-        };
-    }
-    const validation = validateWorkflowPackage(workflowRoot);
-    if (!validation.ok) {
-        copyDirectory(shell.workflowBeforePath, workflowRoot);
-        const summary = `Workflow variation failed validation: ${validation.summary}`;
-        writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            runId: options.runId,
-            loopIndex: options.loopIndex,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-            workflowBeforePath: shell.workflowBeforePath,
-            workflowAfterPath: shell.workflowAfterPath,
-            promptLogPath: shell.promptLogPath,
-            eventLogPath: shell.eventLogPath,
-            statusLogPath: shell.statusLogPath,
-            preservedShellManifestPath,
-            changed: true,
-            validation,
-            result: "invalid",
-            summary,
-        }), {
-            targetName: compiledName,
-            workflowId: options.workflowId,
-            maxLoops: options.maxLoops,
-            maxAttempts: options.maxAttempts,
-        });
-        return {
-            status: "invalid",
-            changed: true,
-            validation,
-            summary,
-            shellPath: shell.rootPath,
-            loopRootPath: shell.loopRootPath,
-        };
-    }
-    writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
-        targetName: compiledName,
-        workflowId: options.workflowId,
-        runId: options.runId,
-        loopIndex: options.loopIndex,
-        shellPath: shell.rootPath,
-        loopRootPath: shell.loopRootPath,
-        workflowBeforePath: shell.workflowBeforePath,
-        workflowAfterPath: shell.workflowAfterPath,
-        promptLogPath: shell.promptLogPath,
-        eventLogPath: shell.eventLogPath,
-        statusLogPath: shell.statusLogPath,
-        preservedShellManifestPath,
-        changed: true,
-        validation,
-        result: "updated",
-        summary: "Workflow variation updated and validated.",
-    }), {
-        targetName: compiledName,
-        workflowId: options.workflowId,
-        maxLoops: options.maxLoops,
-        maxAttempts: options.maxAttempts,
-    });
-    updateCompiledWorkflowOrigin({
-        compiledPath: options.compiledPath,
-        selectedWorkflowId: options.workflowId,
-        localDraft: true,
-    });
-    return {
-        status: "updated",
-        changed: true,
-        validation,
-        summary: "Workflow variation updated and validated.",
-        shellPath: shell.rootPath,
-        loopRootPath: shell.loopRootPath,
-    };
-}
+export * from "../packages/workflow-authoring/workflow-improvement.js";

package/dist/lib/workflow-primitives.d.ts

@@ -1,2 +1 @@
-export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
-export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];
+export * from "../packages/compiler/workflow-primitives.js";

package/dist/lib/workflow-primitives.js

@@ -1,5 +1 @@
-export const COMPILED_ZONE_KINDS = [
-    "directory",
-    "file",
-    "runtime",
-];
+export * from "../packages/compiler/workflow-primitives.js";

package/dist/lib/workflow-review-paths.d.ts

@@ -1,10 +1 @@
-import type { WorkflowImprovementContext } from "./schema.js";
-export interface WorkflowImprovementReviewSourcePaths {
-    compiledRuntime: string | null;
-    testComparisons: string | null;
-    executionShells: string | null;
-    targetTestRuns: string | null;
-    targetTestSandboxes: string | null;
-}
-export declare function resolveWorkflowImprovementReviewSourcePaths(compiledPath: string): WorkflowImprovementReviewSourcePaths;
-export declare function resolveWorkflowImprovementReviewPaths(compiledPath: string): WorkflowImprovementContext["review_paths"];
+export * from "../packages/workflow-package/workflow-review-paths.js";

package/dist/lib/workflow-review-paths.js

@@ -1,27 +1 @@
-import { existsSync } from "node:fs";
-import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "./compiled-paths.js";
-export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
-    const compiledRuntime = compiledRuntimeRoot(compiledPath);
-    const testComparisons = testRootForCompiled(compiledPath);
-    const executionShells = stageExecutionShellsRoot(compiledPath);
-    const targetTestRuns = targetTestRunsRootForCompiled(compiledPath);
-    const targetTestSandboxes = targetTestSandboxesRootForCompiled(compiledPath);
-    return {
-        compiledRuntime: existsSync(compiledRuntime) ? compiledRuntime : null,
-        testComparisons: existsSync(testComparisons) ? testComparisons : null,
-        executionShells: existsSync(executionShells) ? executionShells : null,
-        targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
-        targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,
-    };
-}
-export function resolveWorkflowImprovementReviewPaths(compiledPath) {
-    const sources = resolveWorkflowImprovementReviewSourcePaths(compiledPath);
-    return {
-        workflow_root: "workflow",
-        compiled_runtime: sources.compiledRuntime ? "artifacts/compiled-runtime" : null,
-        test_comparisons: sources.testComparisons ? "artifacts/test-comparisons" : null,
-        execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,
-        test_runs: sources.targetTestRuns ? "artifacts/test-runs" : null,
-        test_sandboxes: sources.targetTestSandboxes ? "artifacts/test-sandboxes" : null,
-    };
-}
+export * from "../packages/workflow-package/workflow-review-paths.js";

package/dist/lib/workflow-stage-policy.d.ts

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/workflow-stage-policy.js";

package/dist/lib/workflow-stage-policy.js

@@ -0,0 +1 @@
+export * from "../packages/workflow-package/workflow-stage-policy.js";