@interf/compiler 0.7.1 → 0.7.3

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

@@ -65,7 +65,7 @@ export function resolveSourceInputPath(compiledPath) {
         const projectPath = resolveSourceControlPathForCompiled(compiledPath);
         return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
     }
-    throw new Error(`Context folder is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
+    throw new Error(`Compiled context is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
 export function listCompiledDatasetsForSourceFolder(sourcePath) {
     const interfRoot = projectInterfRoot(sourcePath);
@@ -82,7 +82,8 @@ export function listCompiledDatasetsForSourceFolder(sourcePath) {
     return readdirSync(interfRoot)
         .filter((entry) => !entry.startsWith(".") &&
         entry !== WORKFLOW_CONTAINER_NAME &&
-        entry !== TEST_CONTAINER_NAME)
+        entry !== TEST_CONTAINER_NAME &&
+        entry !== INTERF_CONFIG_FILE)
         .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
         .filter((compiledPath) => existsSync(compiledPath))
         .map((compiledPath) => {
@@ -102,6 +103,15 @@ export function assertCompiledContainer(sourcePath) {
             if (entry.startsWith("."))
                 return false;
             const entryPath = join(interfRoot, entry);
+            if (entry === INTERF_CONFIG_FILE) {
+                try {
+                    return !statSync(entryPath).isFile();
+                }
+                catch (error) {
+                    warnInterf(`Warning: failed to inspect Interf config path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    return true;
+                }
+            }
             if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
@@ -112,14 +122,12 @@ export function assertCompiledContainer(sourcePath) {
                 }
             }
             try {
-                if (!statSync(entryPath).isDirectory())
-                    return true;
+                return !statSync(entryPath).isDirectory();
             }
             catch (error) {
                 warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
                 return true;
             }
-            return false;
         });
         if (unexpectedRootEntries.length > 0) {
             throw new Error(`Interf container contains unexpected entries: ${interfRoot}`);
@@ -136,6 +144,16 @@ export function assertCompiledContainer(sourcePath) {
     const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
         if (entry.startsWith("."))
             return false;
+        if (entry === INTERF_CONFIG_FILE) {
+            const entryPath = join(containerPath, entry);
+            try {
+                return !statSync(entryPath).isFile();
+            }
+            catch (error) {
+                warnInterf(`Warning: failed to inspect Interf config path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                return true;
+            }
+        }
         if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
             return false;
         const entryPath = join(containerPath, entry);
@@ -147,11 +165,7 @@ export function assertCompiledContainer(sourcePath) {
             warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         }
-        const compiledPath = compiledCompiledPathForDataset(sourcePath, entry);
-        if (!existsSync(compiledPath)) {
-            return false;
-        }
-        return !readInterfConfig(compiledPath);
+        return false;
     });
     if (unexpectedEntries.length > 0) {
         throw new Error(`Interf container contains invalid dataset entries: ${containerPath}`);

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

@@ -1,2 +1,3 @@
+export declare function ensurePortableContextScaffold(sourcePath: string, datasetName: string, workflowId?: string): string;
 export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
 export declare function defaultCompiledNameForSource(sourcePath: string): string;

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

@@ -1,15 +1,16 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
 import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
+import { loadWorkflowDefinitionFromDir, seedLocalDefaultWorkflow } from "../workflow-package/local-workflows.js";
 import { initializeCompiledRuntimeState, } from "../compiler/state.js";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { syncCompiledRawSnapshot } from "../compiler/raw-snapshot.js";
-import { assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
 import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
 import { compiledCompiledPathForDataset } from "./project-paths.js";
 import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../compiler/compiled-schema.js";
 import { findSourceDatasetConfig, listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { defaultControlPathForCompiled, testRootForCompiled, workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
     ".codex/",
@@ -61,14 +62,37 @@ function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
         writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
     }
 }
-export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath) {
-    assertCompiledName(name, "Portable context");
+function localWorkflowMatches(compiledPath, workflowId) {
+    const localWorkflow = loadWorkflowDefinitionFromDir(workflowPackagePathForCompiled(compiledPath));
+    return localWorkflow?.id === workflowId;
+}
+export function ensurePortableContextScaffold(sourcePath, datasetName, workflowId = "interf") {
+    assertCompiledName(datasetName, "Portable context");
     assertCompiledContainer(sourcePath);
-    const compiledPath = compiledCompiledPathForDataset(sourcePath, name);
-    assertWritableTargetDir(compiledPath, "Portable context");
+    const compiledPath = compiledCompiledPathForDataset(sourcePath, datasetName);
     mkdirSync(compiledPath, { recursive: true });
+    mkdirSync(testRootForCompiled(compiledPath), { recursive: true });
+    if (workflowId === "interf-default") {
+        seedLocalDefaultWorkflow({ sourcePath });
+    }
+    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+    if (!localWorkflowMatches(compiledPath, selectedWorkflow.id)) {
+        seedCompiledWorkflowPackage({
+            compiledPath,
+            sourcePath,
+            workflowId: selectedWorkflow.id,
+        });
+    }
+    if (!existsSync(join(compiledPath, ".gitignore"))) {
+        writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
+    }
+    return compiledPath;
+}
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath) {
+    assertCompiledName(name, "Portable context");
     const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
     const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+    const compiledPath = ensurePortableContextScaffold(sourcePath, name, selectedWorkflow.id);
     const resolvedAbout = about ?? savedCompiled?.about;
     const resolvedDatasetPath = (() => {
         if (savedCompiled) {
@@ -108,11 +132,6 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
     mkdirSync(join(compiledPath, "raw"), { recursive: true });
     syncCompiledRawSnapshot(compiledPath, resolvedDatasetPath);
     writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    seedCompiledWorkflowPackage({
-        compiledPath,
-        sourcePath,
-        workflowId: selectedWorkflow.id,
-    });
     scaffoldCompiledOutputs(compiledPath, name, about);
     refreshCompiledBootstrapGuidance(compiledPath);
     writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));

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

@@ -2,4 +2,4 @@ export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, IN
 export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
 export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";
+export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";

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

@@ -1,4 +1,4 @@
 export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";
+export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";

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

@@ -1,7 +1,9 @@
 export declare const PROJECT_INTERF_DIR = "interf";
-export declare const PROJECT_TESTS_DIR = "tests";
+export declare const DATASET_INTERF_DIR = ".interf";
+export declare const PORTABLE_CONTEXT_TESTS_DIR = "tests";
 export declare function projectInterfRoot(projectPath: string): string;
 export declare function compiledCompiledPathForDataset(projectPath: string, datasetName: string): string;
+export declare function portableContextPath(projectPath: string, datasetName: string): string;
 export declare function datasetTestsRoot(projectPath: string, datasetName: string): string;
 export type DatasetTestTargetLabel = "file-as-is" | "compiled";
 export declare function datasetTestRunsRoot(projectPath: string, datasetName: string, target: DatasetTestTargetLabel): string;

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

@@ -1,14 +1,18 @@
 import { join } from "node:path";
 export const PROJECT_INTERF_DIR = "interf";
-export const PROJECT_TESTS_DIR = "tests";
+export const DATASET_INTERF_DIR = ".interf";
+export const PORTABLE_CONTEXT_TESTS_DIR = "tests";
 export function projectInterfRoot(projectPath) {
     return join(projectPath, PROJECT_INTERF_DIR);
 }
 export function compiledCompiledPathForDataset(projectPath, datasetName) {
     return join(projectInterfRoot(projectPath), datasetName);
 }
+export function portableContextPath(projectPath, datasetName) {
+    return compiledCompiledPathForDataset(projectPath, datasetName);
+}
 export function datasetTestsRoot(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), PROJECT_TESTS_DIR, datasetName);
+    return join(portableContextPath(projectPath, datasetName), DATASET_INTERF_DIR, PORTABLE_CONTEXT_TESTS_DIR);
 }
 export function datasetTestRunsRoot(projectPath, datasetName, target) {
     return join(datasetTestsRoot(projectPath, datasetName), target, "runs");

package/dist/packages/project-model/source-config.d.ts

@@ -1,10 +1,15 @@
 import { type InterfConfig, type SourceTruthCheck, type SourceDatasetConfig, type SourceFolderConfig } from "./lib/schema.js";
 import type { TestSpec, TestTargetType } from "../testing/lib/schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
+export declare const SOURCE_FOLDER_CONFIG_PATH = "interf/interf.json";
 export interface LoadedSourceTestSpec extends TestSpec {
     id: string;
     filePath: string;
 }
+export declare function sourceFolderConfigPath(sourcePath: string): string;
+export declare function legacySourceFolderConfigPath(sourcePath: string): string;
+export declare function resolveSourceFolderConfigPath(sourcePath: string): string;
+export declare function migrateLegacySourceFolderConfig(sourcePath: string): boolean;
 export declare function fingerprintTruthChecks(checks: SourceTruthCheck[]): string;
 export declare function loadSourceFolderConfig(sourcePath: string): SourceFolderConfig | null;
 export interface WritableSourceProjectConfig {

package/dist/packages/project-model/source-config.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
@@ -10,10 +10,61 @@ import { SourceFolderConfigSchema, } from "./lib/schema.js";
 import { slugify } from "../shared/naming.js";
 import { assertPathWithinRoot } from "../shared/path-guards.js";
 import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
+import { projectInterfRoot, PROJECT_INTERF_DIR } from "./project-paths.js";
 export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-function sourceConfigPath(sourcePath) {
+export const SOURCE_FOLDER_CONFIG_PATH = `${PROJECT_INTERF_DIR}/${SOURCE_FOLDER_CONFIG_FILE}`;
+export function sourceFolderConfigPath(sourcePath) {
+    return join(projectInterfRoot(sourcePath), SOURCE_FOLDER_CONFIG_FILE);
+}
+export function legacySourceFolderConfigPath(sourcePath) {
     return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
 }
+export function resolveSourceFolderConfigPath(sourcePath) {
+    const primaryPath = sourceFolderConfigPath(sourcePath);
+    if (existsSync(primaryPath))
+        return primaryPath;
+    const legacyPath = legacySourceFolderConfigPath(sourcePath);
+    if (existsSync(legacyPath))
+        return legacyPath;
+    return primaryPath;
+}
+function readSourceFolderConfigFile(filePath) {
+    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
+}
+function readJsonFileUncheckedQuiet(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isValidLegacySourceFolderConfig(sourcePath) {
+    const legacyPath = legacySourceFolderConfigPath(sourcePath);
+    if (!existsSync(legacyPath))
+        return false;
+    const raw = readJsonFileUncheckedQuiet(legacyPath);
+    return SourceFolderConfigSchema.safeParse(raw).success;
+}
+export function migrateLegacySourceFolderConfig(sourcePath) {
+    const primaryPath = sourceFolderConfigPath(sourcePath);
+    const legacyPath = legacySourceFolderConfigPath(sourcePath);
+    if (existsSync(primaryPath) || !existsSync(legacyPath))
+        return false;
+    if (!isValidLegacySourceFolderConfig(sourcePath))
+        return false;
+    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
+    renameSync(legacyPath, primaryPath);
+    return true;
+}
+function removeLegacySourceFolderConfig(sourcePath) {
+    const legacyPath = legacySourceFolderConfigPath(sourcePath);
+    if (!existsSync(legacyPath))
+        return;
+    if (!isValidLegacySourceFolderConfig(sourcePath))
+        return;
+    rmSync(legacyPath, { force: true });
+}
 function normalizeTruthChecks(cases) {
     const seen = new Set();
     return cases.map((caseSpec, index) => {
@@ -47,10 +98,10 @@ export function fingerprintTruthChecks(checks) {
         .slice(0, 16);
 }
 export function loadSourceFolderConfig(sourcePath) {
-    const filePath = sourceConfigPath(sourcePath);
+    const filePath = resolveSourceFolderConfigPath(sourcePath);
     if (!existsSync(filePath))
         return null;
-    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
+    return readSourceFolderConfigFile(filePath);
 }
 export function listSourceDatasetConfigs(config) {
     return config?.datasets ?? [];
@@ -101,7 +152,9 @@ function toWritableSourceDatasetConfig(dataset) {
     };
 }
 export function saveSourceFolderConfig(sourcePath, config) {
-    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
+    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
+    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
+    removeLegacySourceFolderConfig(sourcePath);
 }
 export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
@@ -263,7 +316,7 @@ export function buildTestSpecFromSourceFolderConfig(options) {
             : getDefaultSourceDatasetConfig(config);
     if (!match)
         return null;
-    const configPath = sourceConfigPath(sourcePath);
+    const configPath = resolveSourceFolderConfigPath(sourcePath);
     return buildLoadedTestSpec({
         id: match.id,
         name: match.name,
@@ -273,7 +326,7 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         filePath: targetType === "raw"
             ? `${configPath}#datasets/${match.name}:file-as-is`
             : `${configPath}#datasets/${match.name}:compiled`,
-        fallbackDescription: `Derived from saved dataset checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
+        fallbackDescription: `Derived from saved dataset checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
     });
 }
 export function buildTestSpecFromCompiledDatasetConfig(options) {

package/dist/packages/testing/test-paths.js

@@ -10,7 +10,10 @@ export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
 function isDatasetTestsRootPath(artifactRootPath) {
-    return basename(dirname(artifactRootPath)) === "tests";
+    const portableContextTestsRoot = basename(artifactRootPath) === "tests" &&
+        basename(dirname(artifactRootPath)) === ".interf";
+    const legacyProjectTestsRoot = basename(dirname(artifactRootPath)) === "tests";
+    return portableContextTestsRoot || legacyProjectTestsRoot;
 }
 export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
@@ -19,7 +22,7 @@ export function targetTestRunsPath(compiledPath, type) {
     if (isDatasetTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/tests/<dataset> root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
 }
 export function targetTestRunGitignorePath(compiledPath, type) {
     return join(targetTestRunsPath(compiledPath, type), ".gitignore");
@@ -31,7 +34,7 @@ export function targetTestSandboxesPath(compiledPath, type) {
     if (isDatasetTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/tests/<dataset> root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
 }
 export function targetTestSandboxGitignorePath(compiledPath, type) {
     return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");

package/dist/packages/workflow-authoring/workflow-authoring.js

@@ -13,15 +13,17 @@ function buildWorkflowAuthoringPrompt() {
     return [
         "This is an automated Interf workflow-authoring run, not an open-ended chat session.",
         "Execute it now.",
-        "Create one standalone workflow for the files and checks in this source folder.",
+        "Create one standalone workflow for the source data, desired portable-context outputs, and proof requirements in this source folder.",
         "Read `runtime/authoring-context.json` first.",
+        "Treat `task_prompt` as the user's produce-and-prove brief: source data, output shape, and evidence that should show the data is ready.",
         `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${CONTEXT_INTERFACE_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.",
+        "When editing acceptance rules: `zone_counts_at_least` takes numeric fixed minimums; `zone_counts_at_least_counts` takes runtime count-key strings such as `source_total`, never numbers.",
+        "Make the package materially more specific to this dataset task, output shape, and proof requirement than the seeded base workflow. A no-op copy is not acceptable.",
         "Treat the workflow package as four aligned layers: purpose, inputs, context interface, and stages.",
         "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
         "Do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path.",

package/dist/packages/workflow-authoring/workflow-edit-session.js

@@ -37,13 +37,16 @@ export async function runWorkflowEditSession(options) {
     const validation = options.validate(options.workflowPath);
     if (!validation.ok) {
         copyDirectory(options.shell.workflowBeforePath, options.workflowPath);
+        const details = validation.errors.length > 0
+            ? `: ${validation.errors.slice(0, 6).join("; ")}`
+            : "";
         return {
             status: "invalid",
             changed,
             validation,
             summary: changed
-                ? `Workflow package failed validation: ${validation.summary}`
-                : `Workflow package is invalid without any workflow edits: ${validation.summary}`,
+                ? `Workflow package failed validation: ${validation.summary}${details}`
+                : `Workflow package is invalid without any workflow edits: ${validation.summary}${details}`,
         };
     }
     return {

package/dist/packages/workflow-package/context-interface.js

@@ -13,7 +13,7 @@ export const ContextInterfaceSchema = WorkflowCompiledSchemaSchema;
 export const ContextInterfaceZoneSchema = WorkflowCompiledZoneSchema;
 export const ContextInterfaceZoneIdSchema = WorkflowZoneIdSchema;
 export const ContextInterfaceZoneRoleSchema = WorkflowZoneRoleSchema;
-// Package-owned input contract for authoring, review, and future Studio flows.
+// Package-owned input contract for authoring, review, and future authoring flows.
 // This does not change compiler execution semantics; it describes what data a
 // workflow expects to organize before the compiler materializes the context
 // interface on disk.

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

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { join } from "node:path";
 import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../compiler/compiled-paths.js";
 export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
     const compiledRuntime = compiledRuntimeRoot(compiledPath);
@@ -8,7 +9,10 @@ export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
     const targetTestSandboxes = targetTestSandboxesRootForCompiled(compiledPath);
     return {
         compiledRuntime: existsSync(compiledRuntime) ? compiledRuntime : null,
-        testComparisons: existsSync(testComparisons) ? testComparisons : null,
+        testComparisons: existsSync(join(testComparisons, "latest.json")) ||
+            existsSync(join(testComparisons, "latest.md"))
+            ? testComparisons
+            : null,
         executionShells: existsSync(executionShells) ? executionShells : null,
         targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
         targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.7.1",
-  "description": "Local, open-source context compiler for agent work. Build portable context from your files with a compilation workflow you define. Check on your own questions.",
+  "version": "0.7.3",
+  "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -43,8 +43,6 @@
   "scripts": {
     "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc && chmod 755 dist/bin.js",
     "dev": "tsc --watch",
-    "setup:local-skills": "bash scripts/setup-local-skills.sh",
-    "refresh:bootstrap-mirror": "node scripts/docs/sync-bootstrap-mirror.mjs",
     "docs:sync-public-test-example": "npm run build && node scripts/docs/sync-public-test-example.mjs",
     "test:matrix": "npm run build && node scripts/matrix/run.mjs",
     "test:smoke": "npm run build && node --test test/**/*.test.mjs",