@interf/compiler 0.5.0 → 0.6.1

package/dist/lib/workflow-authoring.js

@@ -0,0 +1,119 @@
+import { mkdtempSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createWorkflowAuthoringShell } from "./agent-shells.js";
+import { WORKFLOW_SCHEMA_FILE } from "./compiled-schema.js";
+import { projectRawSnapshot } from "./compiled-raw.js";
+import { seedLocalWorkflowPackageFromBase } from "./interf-workflow-package.js";
+import { validateWorkflowPackage, workflowDefinitionPath } from "./local-workflows.js";
+import { runWorkflowEditSession } from "./workflow-edit-session.js";
+import { copyDirectory } from "./workflow-edit-utils.js";
+import { createCompiled, compileCompiled } from "./workflows.js";
+function buildWorkflowAuthoringPrompt() {
+    return [
+        "This is an automated Interf workflow-authoring run, not an open-ended chat session.",
+        "Execute it now.",
+        "Read `runtime/authoring-context.json` first.",
+        `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${WORKFLOW_SCHEMA_FILE}\`.`,
+        "Review `artifacts/source-dataset/raw/` and any `artifacts/preview-compiled/` notes before editing the package.",
+        "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
+        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
+        "Edit only files under `workflow/`.",
+        "Keep the workflow valid for the current compiler API and workflow schema.",
+        "Make the package materially more specific to this dataset task than the seeded base workflow. A no-op copy is not acceptable.",
+        "Prefer explicit stage-doc, stage-policy, purpose, and zone-contract edits over vague rewrites.",
+        "Do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Do not make one stage point at files or notes that are only created later by another stage.",
+        "Prefer conservative retrieval routing over speculative note sprawl.",
+        "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");
+}
+async function prepareWorkflowAuthoringPreview(options) {
+    const tempRoot = mkdtempSync(join(tmpdir(), "interf-workflow-preview-"));
+    projectRawSnapshot({
+        sourcePath: options.datasetPath,
+        destinationPath: tempRoot,
+        compiledPath: tempRoot,
+        mode: "copy",
+        prune: true,
+        preserveTimestamps: true,
+    });
+    copyDirectory(options.workflowPath, workflowDefinitionPath(tempRoot, options.workflowId));
+    const compiledPath = createCompiled("preview", tempRoot, options.workflowId, options.about, tempRoot);
+    const result = await compileCompiled({
+        executor: options.executor,
+        compiledPath,
+        ...(options.reporter ? { reporter: options.reporter } : {}),
+        preserveStageShells: "on-failure",
+    });
+    return {
+        tempRoot,
+        compiledPath,
+        compileResult: {
+            ok: result.ok,
+            failedStage: result.failedStage,
+        },
+    };
+}
+export async function runWorkflowAuthoringDraft(options) {
+    const workflowPath = seedLocalWorkflowPackageFromBase({
+        sourcePath: options.sourcePath,
+        baseWorkflowId: options.baseWorkflowId,
+        workflowId: options.workflowId,
+        label: options.label,
+        hint: options.hint,
+    });
+    let preview = null;
+    try {
+        if (options.preparePreview !== false) {
+            preview = await prepareWorkflowAuthoringPreview({
+                datasetPath: options.datasetPath,
+                about: options.taskPrompt,
+                workflowId: options.workflowId,
+                workflowPath,
+                executor: options.executor,
+                reporter: options.previewReporter ?? null,
+            });
+        }
+        const shell = createWorkflowAuthoringShell({
+            workflowPath,
+            workflowId: options.workflowId,
+            label: options.label,
+            baseWorkflowId: options.baseWorkflowId,
+            datasetPath: options.datasetPath,
+            taskPrompt: options.taskPrompt,
+            checks: options.checks ?? [],
+            preview,
+        });
+        if (preview) {
+            rmSync(preview.tempRoot, { recursive: true, force: true });
+            preview = null;
+        }
+        const session = await runWorkflowEditSession({
+            executor: options.executor,
+            workflowPath,
+            shell,
+            prompt: buildWorkflowAuthoringPrompt(),
+            validate: validateWorkflowPackage,
+        });
+        return {
+            status: session.status,
+            changed: session.changed,
+            summary: session.summary,
+            validation: session.validation,
+            workflowPath,
+            shellPath: shell.rootPath,
+        };
+    }
+    finally {
+        if (preview) {
+            rmSync(preview.tempRoot, { recursive: true, force: true });
+        }
+    }
+}
+export function resolveWorkflowDraftPath(sourcePath, workflowId) {
+    return workflowDefinitionPath(sourcePath, workflowId);
+}

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

@@ -1,4 +1,4 @@
-import type { RuntimeContractType, RuntimeStageAcceptance, WorkflowCompilerApi, WorkflowId, WorkflowZoneId } from "./schema.js";
+import type { RuntimeContractType, RuntimeStageAcceptance, WorkflowCompilerApi, WorkflowCompiledSchema, WorkflowId, WorkflowZoneId } from "./schema.js";
 export interface WorkflowStarterDoc {
     relativePath: string;
     content: string;
@@ -16,9 +16,14 @@ export interface WorkflowStageDefinition {
 export interface WorkflowDefinition<TId extends string> {
     id: TId;
     compilerApi?: WorkflowCompilerApi;
+    purpose?: {
+        label: string;
+        taskHint: string;
+    };
     label: string;
     hint: string;
     recommended?: boolean;
+    schema?: WorkflowCompiledSchema;
     stages: WorkflowStageDefinition[];
     stagePolicyNotes?: Record<string, string[]>;
     starterDocs?: WorkflowStarterDoc[];
@@ -28,6 +33,10 @@ export type CompiledWorkflowId = string;
 export declare function standaloneWorkflowDefinitionFromLocalPackage(local: {
     id: string;
     compiler_api?: WorkflowCompilerApi;
+    purpose?: {
+        label: string;
+        task_hint: string;
+    };
     label: string;
     hint: string;
     stages?: Array<{
@@ -41,6 +50,7 @@ export declare function standaloneWorkflowDefinitionFromLocalPackage(local: {
         acceptance?: RuntimeStageAcceptance;
     }>;
     stage_policy_notes?: Record<string, string[]>;
+    workflow_schema?: WorkflowCompiledSchema;
     starter_docs: WorkflowStarterDoc[];
 }): WorkflowDefinition<string>;
 export declare function listCompiledWorkflowChoices(sourcePath?: string): WorkflowDefinition<string>[];
@@ -48,8 +58,9 @@ export declare function getCompiledWorkflow(workflowId: CompiledWorkflowId, opti
     sourcePath?: string;
 }): WorkflowDefinition<string>;
 export declare function getActiveCompiledWorkflow(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId): WorkflowDefinition<string>;
-export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId;
-export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId;
+export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId | null;
+export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId | null;
+export declare function resolveRequiredCompiledWorkflowFromConfig(config: unknown, label?: string): CompiledWorkflowId;
 export declare function formatCompiledWorkflowStageStep(workflowId: CompiledWorkflowId, stage: string, options?: {
     sourcePath?: string;
 }): string;

package/dist/lib/workflow-definitions.js

@@ -5,6 +5,7 @@ import { PACKAGE_ROOT } from "./config.js";
 import { resolveSourceControlPath } from "./interf.js";
 import { warnInterf } from "./logger.js";
 import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { mergeStagePolicyNotesForStages } from "./workflow-stage-policy.js";
 let builtinInterfWorkflowCache = null;
 function toWorkflowStages(stages, fallbackStages) {
     if (!stages || stages.length === 0)
@@ -20,19 +21,6 @@ function toWorkflowStages(stages, fallbackStages) {
         ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
     }));
 }
-function mergeStagePolicyNotes(stages, baseNotes, overrideNotes) {
-    const merged = {};
-    for (const definition of stages) {
-        const combined = Array.from(new Set([
-            ...(baseNotes?.[definition.id] ?? []),
-            ...((overrideNotes?.[definition.id] ?? []).filter((note) => note.trim().length > 0)),
-        ]));
-        if (combined.length > 0) {
-            merged[definition.id] = combined;
-        }
-    }
-    return Object.keys(merged).length > 0 ? merged : undefined;
-}
 export function standaloneWorkflowDefinitionFromLocalPackage(local) {
     if (!local.stages || local.stages.length === 0) {
         throw new Error(`Workflow package "${local.id}" is missing explicit stages. Compiled-local and portable workflow packages must be standalone.`);
@@ -44,11 +32,20 @@ export function standaloneWorkflowDefinitionFromLocalPackage(local) {
             kind: "compiled",
             version: 1,
         },
+        ...(local.purpose
+            ? {
+                purpose: {
+                    label: local.purpose.label,
+                    taskHint: local.purpose.task_hint,
+                },
+            }
+            : {}),
         label: local.label,
         hint: local.hint,
         recommended: false,
+        ...(local.workflow_schema ? { schema: local.workflow_schema } : {}),
         stages,
-        stagePolicyNotes: mergeStagePolicyNotes(stages, undefined, local.stage_policy_notes),
+        stagePolicyNotes: mergeStagePolicyNotesForStages(stages, undefined, local.stage_policy_notes),
         starterDocs: [...local.starter_docs],
         scope: "local",
     };
@@ -113,7 +110,7 @@ export function getCompiledWorkflow(workflowId, options = {}) {
             return local;
         throw new Error(`No local workflow package found for "${workflowId}" under ${join(options.sourcePath, "interf", "workflows", workflowId)}.`);
     }
-    throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf Compiler can resolve a local workflow package.`);
+    throw new Error(`Workflow "${workflowId}" is not built-in. Provide a source path so Interf can resolve a local workflow package.`);
 }
 export function getActiveCompiledWorkflow(compiledPath, fallbackWorkflowId) {
     const workflowPath = workflowPackagePathForCompiled(compiledPath);
@@ -133,14 +130,21 @@ export function resolveCompiledWorkflowId(value) {
     if (typeof value === "string" && isWorkflowId(value)) {
         return value;
     }
-    return "interf";
+    return null;
 }
 export function resolveCompiledWorkflowFromConfig(config) {
     if (!config || typeof config !== "object")
-        return "interf";
+        return null;
     const raw = config;
     return resolveCompiledWorkflowId(raw.workflow);
 }
+export function resolveRequiredCompiledWorkflowFromConfig(config, label = "compiled config") {
+    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    if (!workflowId) {
+        throw new Error(`Missing or invalid workflow in ${label}.`);
+    }
+    return workflowId;
+}
 export function formatCompiledWorkflowStageStep(workflowId, stage, options = {}) {
     return formatWorkflowStageStep(getCompiledWorkflow(workflowId, options), stage);
 }

package/dist/lib/workflow-edit-session.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowExecutor } from "./executors.js";
+import type { WorkflowValidationResult } from "./local-workflows.js";
+import { type WorkflowEditShellArtifacts } from "./workflow-edit-utils.js";
+export interface WorkflowEditSessionResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: WorkflowValidationResult | null;
+    summary: string;
+}
+export declare function runWorkflowEditSession(options: {
+    executor: WorkflowExecutor;
+    workflowPath: string;
+    shell: WorkflowEditShellArtifacts;
+    prompt: string;
+    validate: (workflowPath: string) => WorkflowValidationResult;
+}): Promise<WorkflowEditSessionResult>;

package/dist/lib/workflow-edit-session.js

@@ -0,0 +1,57 @@
+import { writeFileSync } from "node:fs";
+import { copyDirectory, directoriesMatch } from "./workflow-edit-utils.js";
+export async function runWorkflowEditSession(options) {
+    copyDirectory(options.workflowPath, options.shell.workflowBeforePath);
+    writeFileSync(options.shell.promptLogPath, `${options.prompt}\n`);
+    let code = 1;
+    let executeError = null;
+    try {
+        code = await options.executor.execute(options.shell.rootPath, options.prompt, {
+            eventLogPath: options.shell.eventLogPath,
+            statusLogPath: options.shell.statusLogPath,
+        });
+    }
+    catch (error) {
+        executeError = error instanceof Error ? error.message : String(error);
+    }
+    copyDirectory(options.workflowPath, options.shell.workflowAfterPath);
+    const changed = !directoriesMatch(options.shell.workflowBeforePath, options.shell.workflowAfterPath);
+    if (executeError) {
+        copyDirectory(options.shell.workflowBeforePath, options.workflowPath);
+        return {
+            status: "executor-failed",
+            changed,
+            validation: null,
+            summary: `Workflow editor failed before completing: ${executeError}`,
+        };
+    }
+    if (code !== 0) {
+        copyDirectory(options.shell.workflowBeforePath, options.workflowPath);
+        return {
+            status: "executor-failed",
+            changed,
+            validation: null,
+            summary: `Workflow editor exited with code ${code}.`,
+        };
+    }
+    const validation = options.validate(options.workflowPath);
+    if (!validation.ok) {
+        copyDirectory(options.shell.workflowBeforePath, options.workflowPath);
+        return {
+            status: "invalid",
+            changed,
+            validation,
+            summary: changed
+                ? `Workflow package failed validation: ${validation.summary}`
+                : `Workflow package is invalid without any workflow edits: ${validation.summary}`,
+        };
+    }
+    return {
+        status: changed ? "updated" : "no-change",
+        changed,
+        validation,
+        summary: changed
+            ? "Workflow package updated and validated."
+            : "Workflow package is valid without additional edits.",
+    };
+}

package/dist/lib/workflow-edit-utils.d.ts

@@ -0,0 +1,10 @@
+export declare function copyDirectory(sourcePath: string, targetPath: string): void;
+export declare function directoriesMatch(leftPath: string, rightPath: string): boolean;
+export interface WorkflowEditShellArtifacts {
+    rootPath: string;
+    workflowBeforePath: string;
+    workflowAfterPath: string;
+    promptLogPath: string;
+    eventLogPath: string;
+    statusLogPath: string;
+}

package/dist/lib/workflow-edit-utils.js

@@ -0,0 +1,39 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { join, relative } from "node:path";
+export 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;
+}
+export 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;
+}

package/dist/lib/workflow-improvement.js

@@ -1,4 +1,4 @@
-import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
 import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from "./agent-shells.js";
 import { readInterfConfig } from "./interf.js";
@@ -7,44 +7,9 @@ import { readJsonFileWithSchema } from "./parse.js";
 import { saveCompiledInterfConfig } from "./source-config.js";
 import { WorkflowImprovementRunLedgerSchema, } from "./schema.js";
 import { resolveWorkflowImprovementReviewPaths } from "./workflow-review-paths.js";
+import { runWorkflowEditSession } from "./workflow-edit-session.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;
-}
+import { WORKFLOW_SCHEMA_FILE } from "./compiled-schema.js";
 function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     if (!absolutePath)
         return null;
@@ -90,16 +55,18 @@ function buildLoopContext(options) {
 }
 function buildWorkflowImprovementPrompt() {
     return [
-        "This is an automated Interf Compiler workflow-improvement run, not an open-ended chat session.",
+        "This is an automated Interf 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.",
+        `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, \`workflow/${WORKFLOW_SCHEMA_FILE}\`, 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.",
+        "Keep the workflow valid for the current compiler API and workflow schema.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Do not make one stage point at files or notes that are only created later by another stage.",
         "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:.",
@@ -193,170 +160,14 @@ export async function runWorkflowImprovementLoop(options) {
         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 session = await runWorkflowEditSession({
+        executor: options.executor,
+        workflowPath: workflowRoot,
+        shell,
+        prompt: buildWorkflowImprovementPrompt(),
+        validate: validateWorkflowPackage,
+    });
     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,
@@ -370,26 +181,28 @@ export async function runWorkflowImprovementLoop(options) {
         eventLogPath: shell.eventLogPath,
         statusLogPath: shell.statusLogPath,
         preservedShellManifestPath,
-        changed: true,
-        validation,
-        result: "updated",
-        summary: "Workflow variation updated and validated.",
+        changed: session.changed,
+        validation: session.validation,
+        result: session.status,
+        summary: session.summary,
     }), {
         targetName: compiledName,
         workflowId: options.workflowId,
         maxLoops: options.maxLoops,
         maxAttempts: options.maxAttempts,
     });
-    updateCompiledWorkflowOrigin({
-        compiledPath: options.compiledPath,
-        selectedWorkflowId: options.workflowId,
-        localDraft: true,
-    });
+    if (session.status === "updated") {
+        updateCompiledWorkflowOrigin({
+            compiledPath: options.compiledPath,
+            selectedWorkflowId: options.workflowId,
+            localDraft: true,
+        });
+    }
     return {
-        status: "updated",
-        changed: true,
-        validation,
-        summary: "Workflow variation updated and validated.",
+        status: session.status,
+        changed: session.changed,
+        validation: session.validation,
+        summary: session.summary,
         shellPath: shell.rootPath,
         loopRootPath: shell.loopRootPath,
     };

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

@@ -0,0 +1,2 @@
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];