@interf/compiler 0.5.1 → 0.6.1

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-stage-policy.d.ts

@@ -0,0 +1,5 @@
+export interface StagePolicyStageLike {
+    id: string;
+}
+export declare function normalizeStagePolicyNotes(value: unknown): Record<string, string[]> | undefined;
+export declare function mergeStagePolicyNotesForStages(stages: readonly StagePolicyStageLike[], baseNotes: unknown, overrideNotes: Record<string, string[]> | undefined): Record<string, string[]> | undefined;

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

@@ -0,0 +1,31 @@
+export function normalizeStagePolicyNotes(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const normalized = {};
+    for (const [stageId, notes] of Object.entries(value)) {
+        if (!Array.isArray(notes))
+            continue;
+        const cleaned = Array.from(new Set(notes
+            .filter((note) => typeof note === "string")
+            .map((note) => note.trim())
+            .filter((note) => note.length > 0)));
+        if (cleaned.length > 0) {
+            normalized[stageId] = cleaned;
+        }
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+export function mergeStagePolicyNotesForStages(stages, baseNotes, overrideNotes) {
+    const normalizedBase = normalizeStagePolicyNotes(baseNotes);
+    const merged = {};
+    for (const stage of stages) {
+        const combined = Array.from(new Set([
+            ...(normalizedBase?.[stage.id] ?? []),
+            ...((overrideNotes?.[stage.id] ?? []).map((note) => note.trim()).filter((note) => note.length > 0)),
+        ]));
+        if (combined.length > 0) {
+            merged[stage.id] = combined;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.5.1",
-  "description": "Interf Compiler is a local runtime for data-processing workflows that prepare datasets for accurate local agent use.",
+  "version": "0.6.1",
+  "description": "Interf helps make data ready for agent work. Measure raw files first, then prepare a compiled dataset when you need it.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -37,13 +37,14 @@
     "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-project-clones",
     "test:full": "npm test && npm run test:e2e:quick:matrix",
     "test:release:matrix": "npm run test:internal:cbre:max",
-    "test:release": "npm test && npm run test:acceptance-live -- --agent claude-code --with-test && npm run test:acceptance-live -- --agent codex --with-test",
+    "test:release": "npm test && npm run test:acceptance-quick:workflow-authoring -- --agent claude-code && npm run test:acceptance-live -- --agent claude-code --with-test && npm run test:acceptance-quick:workflow-authoring -- --agent codex && npm run test:acceptance-live -- --agent codex --with-test",
     "test:acceptance-live": "npm run build && node scripts/acceptance-live.mjs",
     "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude && npm run test:acceptance-cache:refresh:codex",
     "test:acceptance-cache:refresh:claude": "node scripts/acceptance-cache-refresh.mjs --agent claude-code",
     "test:acceptance-cache:refresh:codex": "node scripts/acceptance-cache-refresh.mjs --agent codex",
     "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance-targeted.mjs create-compiled",
     "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance-targeted.mjs compiled-query",
+    "test:acceptance-quick:workflow-authoring": "npm run build && node scripts/acceptance-targeted.mjs workflow-authoring",
     "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance-targeted.mjs self-improving-compile",
     "prepublishOnly": "node scripts/prepublish-gate.mjs"
   },
@@ -59,8 +60,6 @@
     "interf",
     "ai",
     "agent",
-    "knowledge",
-    "obsidian",
     "coding-agent",
     "claude",
     "codex"

package/dist/lib/obsidian.d.ts

@@ -1 +0,0 @@
-export declare function writeObsidianDefaults(dirPath: string, type: "compiled"): void;

package/dist/lib/obsidian.js

@@ -1,15 +0,0 @@
-import { mkdirSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-export function writeObsidianDefaults(dirPath, type) {
-    const obsidianDir = join(dirPath, ".obsidian");
-    mkdirSync(obsidianDir, { recursive: true });
-    const graphSettings = {
-        "collapse-filter": true,
-        search: 'path:"summaries" OR path:"knowledge" OR path:"home"',
-        showTags: false,
-        showAttachments: false,
-        hideUnresolved: true,
-        showOrphans: false,
-    };
-    writeFileSync(join(obsidianDir, "graph.json"), JSON.stringify(graphSettings, null, 2) + "\n");
-}

package/dist/lib/summarize-plan.d.ts

@@ -1,17 +0,0 @@
-export interface SummarizeTarget {
-    source: string;
-    summary: string | null;
-    output: string;
-    reason: "pending" | "missing_synth" | "changed" | "full_pass";
-}
-export interface SummarizePlan {
-    generatedAt: string;
-    sourceCount: number;
-    summaryCount: number;
-    pendingCount: number;
-    targetCount: number;
-    targets: SummarizeTarget[];
-}
-export declare const SUMMARIZE_PLAN_RELATIVE_PATH: string;
-export declare function buildSummarizePlan(sourcePath: string, compiledPath: string, mode?: "pending" | "all"): SummarizePlan;
-export declare function writeSummarizePlan(compiledPath: string, plan: SummarizePlan): string;

package/dist/lib/summarize-plan.js

@@ -1,120 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
-import { listFilesRecursive } from "./filesystem.js";
-import { builtinCompiledZoneRelativePath, compiledSummariesPath, BUILTIN_COMPILED_ZONE_IDS, } from "./compiled-schema.js";
-import { discoverSourceFiles } from "./discovery.js";
-import { loadState } from "./state.js";
-import { parseJsonFrontmatter } from "./parse.js";
-import { compiledRuntimeRoot } from "./compiled-paths.js";
-export const SUMMARIZE_PLAN_RELATIVE_PATH = join(".interf", "runtime", "summarize-targets.json");
-export function buildSummarizePlan(sourcePath, compiledPath, mode = "pending") {
-    const discovery = discoverSourceFiles(sourcePath, compiledPath);
-    const sourceFiles = discovery.sourceFiles;
-    const summariesDir = compiledSummariesPath(compiledPath);
-    const summaryFiles = listSummaryFiles(summariesDir, compiledPath);
-    const state = loadState(compiledPath);
-    const pending = new Set((state?.pending ?? []).filter((value) => typeof value === "string" && sourceFiles.includes(value)));
-    const summaryIndex = new Map();
-    for (const summary of summaryFiles) {
-        const source = readSourceReference(join(compiledPath, summary));
-        if (source)
-            summaryIndex.set(source, summary);
-    }
-    const targets = new Map();
-    if (mode === "all") {
-        for (const src of sourceFiles) {
-            targets.set(src, {
-                source: src,
-                summary: summaryIndex.get(src) ?? null,
-                output: defaultSummaryPath(src),
-                reason: "full_pass",
-            });
-        }
-        return {
-            generatedAt: new Date().toISOString(),
-            sourceCount: sourceFiles.length,
-            summaryCount: summaryFiles.length,
-            pendingCount: pending.size,
-            targetCount: targets.size,
-            targets: Array.from(targets.values()).sort((a, b) => a.source.localeCompare(b.source)),
-        };
-    }
-    for (const src of pending) {
-        targets.set(src, {
-            source: src,
-            summary: summaryIndex.get(src) ?? null,
-            output: defaultSummaryPath(src),
-            reason: "pending",
-        });
-    }
-    for (const src of sourceFiles) {
-        if (summaryIndex.has(src))
-            continue;
-        if (targets.has(src))
-            continue;
-        targets.set(src, {
-            source: src,
-            summary: null,
-            output: defaultSummaryPath(src),
-            reason: "missing_synth",
-        });
-    }
-    // Detect changed source files (source newer than its summary)
-    for (const [src, summary] of summaryIndex) {
-        if (targets.has(src))
-            continue;
-        const sourceFile = join(sourcePath, src);
-        const synthFile = join(compiledPath, summary);
-        if (!existsSync(sourceFile) || !existsSync(synthFile))
-            continue;
-        try {
-            const sourceMtime = statSync(sourceFile).mtimeMs;
-            const synthMtime = statSync(synthFile).mtimeMs;
-            if (sourceMtime > synthMtime) {
-                targets.set(src, {
-                    source: src,
-                    summary,
-                    output: defaultSummaryPath(src),
-                    reason: "changed",
-                });
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return {
-        generatedAt: new Date().toISOString(),
-        sourceCount: sourceFiles.length,
-        summaryCount: summaryFiles.length,
-        pendingCount: pending.size,
-        targetCount: targets.size,
-        targets: Array.from(targets.values()).sort((a, b) => a.source.localeCompare(b.source)),
-    };
-}
-export function writeSummarizePlan(compiledPath, plan) {
-    const planPath = join(compiledPath, SUMMARIZE_PLAN_RELATIVE_PATH);
-    mkdirSync(compiledRuntimeRoot(compiledPath), { recursive: true });
-    writeFileSync(planPath, JSON.stringify(plan, null, 2) + "\n");
-    return planPath;
-}
-function listSummaryFiles(summariesDir, compiledPath) {
-    return listFilesRecursive(summariesDir, (filePath) => filePath.endsWith(".md")).map((filePath) => relative(compiledPath, filePath));
-}
-function readSourceReference(synthPath) {
-    if (!existsSync(synthPath))
-        return null;
-    const content = readFileSync(synthPath, "utf-8");
-    const parsed = parseJsonFrontmatter(content);
-    const source = typeof parsed?.frontmatter.source === "string"
-        ? parsed.frontmatter.source
-        : null;
-    return source?.trim() ?? null;
-}
-function defaultSummaryPath(sourcePath) {
-    const summariesRoot = builtinCompiledZoneRelativePath(BUILTIN_COMPILED_ZONE_IDS.SUMMARIES);
-    if (sourcePath.endsWith(".md"))
-        return `${summariesRoot}/${sourcePath}`;
-    const replaced = sourcePath.replace(/\.[^.]+$/, ".md");
-    return `${summariesRoot}/${replaced === sourcePath ? `${sourcePath}.md` : replaced}`;
-}