@interf/compiler 0.7.2 → 0.9.1

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

@@ -7,10 +7,14 @@ import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "
 import { InterfConfigSchema, } from "./lib/schema.js";
 import { assertPathWithinRoot } from "../shared/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
-export const WORKFLOW_CONTAINER_NAME = "workflows";
+export const METHOD_CONTAINER_NAME = "methods";
+export const WORKFLOW_CONTAINER_NAME = METHOD_CONTAINER_NAME;
+export const LEGACY_WORKFLOW_CONTAINER_NAME = "workflows";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
-export const WORKFLOW_PACKAGE_DIR = "workflow";
+export const METHOD_PACKAGE_DIR = "method";
+export const WORKFLOW_PACKAGE_DIR = METHOD_PACKAGE_DIR;
+export const LEGACY_WORKFLOW_PACKAGE_DIR = "workflow";
 export function readInterfConfig(dirPath) {
     const configPath = compiledInterfConfigPath(dirPath);
     if (!existsSync(configPath))
@@ -61,11 +65,17 @@ export function resolveSourceControlPath(compiledPath) {
 }
 export function resolveSourceInputPath(compiledPath) {
     const config = readInterfConfig(compiledPath);
-    if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
-        const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-        return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
+    const sourceBinding = typeof config?.source?.preparation_path === "string" && config.source.preparation_path.length > 0
+        ? config.source.preparation_path
+        : typeof config?.source?.source_folder_path === "string" && config.source.source_folder_path.length > 0
+            ? config.source.source_folder_path
+            : typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0
+                ? config.source.dataset_path
+                : null;
+    if (sourceBinding) {
+        return resolve(compiledPath, sourceBinding);
     }
-    throw new Error(`Context folder is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
+    throw new Error(`Portable context is missing source.preparation_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
 export function listCompiledDatasetsForSourceFolder(sourcePath) {
     const interfRoot = projectInterfRoot(sourcePath);
@@ -82,7 +92,9 @@ export function listCompiledDatasetsForSourceFolder(sourcePath) {
     return readdirSync(interfRoot)
         .filter((entry) => !entry.startsWith(".") &&
         entry !== WORKFLOW_CONTAINER_NAME &&
-        entry !== TEST_CONTAINER_NAME)
+        entry !== LEGACY_WORKFLOW_CONTAINER_NAME &&
+        entry !== TEST_CONTAINER_NAME &&
+        entry !== INTERF_CONFIG_FILE)
         .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
         .filter((compiledPath) => existsSync(compiledPath))
         .map((compiledPath) => {
@@ -102,24 +114,33 @@ export function assertCompiledContainer(sourcePath) {
             if (entry.startsWith("."))
                 return false;
             const entryPath = join(interfRoot, entry);
-            if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
+            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 === LEGACY_WORKFLOW_CONTAINER_NAME ||
+                entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
                 }
                 catch (error) {
-                    warnInterf(`Warning: failed to inspect Interf control-plane path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    warnInterf(`Warning: failed to inspect Interf Workspace path at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
                     return true;
                 }
             }
             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,7 +157,19 @@ export function assertCompiledContainer(sourcePath) {
     const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
         if (entry.startsWith("."))
             return false;
-        if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
+        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 === LEGACY_WORKFLOW_CONTAINER_NAME ||
+            entry === TEST_CONTAINER_NAME)
             return false;
         const entryPath = join(containerPath, entry);
         try {
@@ -147,14 +180,10 @@ 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}`);
+        throw new Error(`Interf container contains invalid Preparation entries: ${containerPath}`);
     }
     return 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 { findSourceDatasetConfig, listSourceDatasetConfigs, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { defaultControlPathForCompiled, testRootForCompiled, workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
     ".codex/",
@@ -61,14 +62,40 @@ 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 });
-    const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
+    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 effectiveWorkflowId = workflowId === "interf"
+        ? methodIdForSourcePreparationConfig(savedCompiled) ?? workflowId
+        : workflowId;
+    const selectedWorkflow = getCompiledWorkflow(effectiveWorkflowId, { sourcePath });
+    const compiledPath = ensurePortableContextScaffold(sourcePath, name, selectedWorkflow.id);
     const resolvedAbout = about ?? savedCompiled?.about;
     const resolvedDatasetPath = (() => {
         if (savedCompiled) {
@@ -81,13 +108,13 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
         if (configuredDatasets.length === 1) {
             return resolveSourceDatasetPath(sourcePath, configuredDatasets[0]);
         }
-        throw new Error("Cannot infer the source folder for this portable context. Select a source folder first or pass an explicit dataset path.");
+        throw new Error("Cannot infer the source folder for this portable context. Select a source folder first or pass an explicit source folder path.");
     })();
     saveCompiledInterfConfig(compiledPath, {
         type: "compiled",
         name,
         ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        workflow: selectedWorkflow.id,
+        method: selectedWorkflow.id,
         ...(typeof savedCompiled?.max_attempts === "number"
             ? { max_attempts: savedCompiled.max_attempts }
             : {}),
@@ -95,24 +122,19 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
             ? { max_loops: savedCompiled.max_loops }
             : {}),
         checks: savedCompiled?.checks ?? [],
-        workflow_origin: {
+        method_origin: {
             selected: selectedWorkflow.id,
             local_draft: false,
         },
         source: {
             path: "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
+            preparation_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
         },
     });
     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

@@ -1,5 +1,5 @@
-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 { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, LEGACY_WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, WORKFLOW_PACKAGE_DIR, LEGACY_WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 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 { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, LEGACY_WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, WORKFLOW_PACKAGE_DIR, LEGACY_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/lib/schema.d.ts

@@ -1,6 +1,8 @@
 import { z } from "zod";
 export declare const DatasetNameSchema: z.ZodString;
-export declare const SourceTruthCheckSchema: z.ZodObject<{
+export declare const PreparationNameSchema: z.ZodString;
+export declare const MethodIdSchema: z.ZodString;
+export declare const SourceReadinessCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
     answer: z.ZodOptional<z.ZodString>;
@@ -13,11 +15,35 @@ export declare const SourceTruthCheckSchema: z.ZodObject<{
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+export declare const SourcePreparationConfigSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    path: z.ZodString;
+    about: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodString>;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+    max_loops: z.ZodOptional<z.ZodNumber>;
+    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        question: z.ZodString;
+        answer: z.ZodOptional<z.ZodString>;
+        expect: z.ZodOptional<z.ZodObject<{
+            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min_words: z.ZodOptional<z.ZodNumber>;
+            max_words: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        strictness: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export declare const SourceDatasetConfigSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     path: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodString>;
     workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
@@ -35,11 +61,15 @@ export declare const SourceDatasetConfigSchema: z.ZodObject<{
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
+export declare const SourceFolderBindingSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
 export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodString;
+    method: z.ZodString;
+    workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -55,6 +85,10 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    method_origin: z.ZodOptional<z.ZodObject<{
+        selected: z.ZodString;
+        local_draft: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
     workflow_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
@@ -62,14 +96,17 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodString;
+        preparation_path: z.ZodOptional<z.ZodString>;
+        source_folder_path: z.ZodOptional<z.ZodString>;
+        dataset_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const InterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodString;
+    method: z.ZodString;
+    workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -85,6 +122,10 @@ export declare const InterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
+    method_origin: z.ZodOptional<z.ZodObject<{
+        selected: z.ZodString;
+        local_draft: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
     workflow_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
@@ -92,15 +133,44 @@ export declare const InterfConfigSchema: z.ZodObject<{
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodString;
+        preparation_path: z.ZodOptional<z.ZodString>;
+        source_folder_path: z.ZodOptional<z.ZodString>;
+        dataset_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const SourceFolderConfigSchema: z.ZodObject<{
+    source_folder: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        path: z.ZodString;
+        about: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodString>;
+        workflow: z.ZodOptional<z.ZodString>;
+        max_attempts: z.ZodOptional<z.ZodNumber>;
+        max_loops: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            question: z.ZodString;
+            answer: z.ZodOptional<z.ZodString>;
+            expect: z.ZodOptional<z.ZodObject<{
+                must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                min_words: z.ZodOptional<z.ZodNumber>;
+                max_words: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            strictness: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
     datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
         path: z.ZodString;
         about: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodString>;
         workflow: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
         max_loops: z.ZodOptional<z.ZodNumber>;
@@ -119,7 +189,11 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
-export type SourceTruthCheck = z.infer<typeof SourceTruthCheckSchema>;
+export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
+export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
 export type SourceDatasetConfig = z.infer<typeof SourceDatasetConfigSchema>;
+export type PreparationName = z.infer<typeof PreparationNameSchema>;
+export type MethodId = z.infer<typeof MethodIdSchema>;
+export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;
 export type InterfConfig = z.infer<typeof InterfConfigSchema>;
 export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;

package/dist/packages/project-model/lib/schema.js

@@ -1,12 +1,14 @@
 import { z } from "zod";
 import { SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, WorkflowIdPattern, WorkflowIdSchema, } from "../../compiler/lib/schema.js";
 const DatasetNamePattern = /^[a-z0-9][a-z0-9-]*$/;
-const RESERVED_DATASET_NAMES = new Set(["tests", "workflows"]);
+const RESERVED_DATASET_NAMES = new Set(["tests", "methods", "workflows"]);
 export const DatasetNameSchema = z
     .string()
-    .regex(DatasetNamePattern, "Dataset names must use lowercase letters, numbers, and dashes only.")
-    .refine((value) => !RESERVED_DATASET_NAMES.has(value), "Dataset name is reserved.");
-export const SourceTruthCheckSchema = z.object({
+    .regex(DatasetNamePattern, "Preparation names must use lowercase letters, numbers, and dashes only.")
+    .refine((value) => !RESERVED_DATASET_NAMES.has(value), "Preparation name is reserved.");
+export const PreparationNameSchema = DatasetNameSchema;
+export const MethodIdSchema = WorkflowIdSchema;
+export const SourceReadinessCheckSchema = z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
     question: z.string().min(1),
     answer: z.string().min(1).optional(),
@@ -17,28 +19,38 @@ export const SourceTruthCheckSchema = z.object({
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["answer"],
-            message: "Truth checks need `answer` or `expect`.",
+            message: "Readiness checks need `answer` or `expect`.",
         });
     }
 });
-export const SourceDatasetConfigSchema = z.object({
+export const SourcePreparationConfigSchema = z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
-    name: DatasetNameSchema,
+    name: PreparationNameSchema,
     path: z.string().min(1),
     about: z.string().min(1).optional(),
+    method: MethodIdSchema.optional(),
     workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+}).strict();
+export const SourceDatasetConfigSchema = SourcePreparationConfigSchema;
+export const SourceFolderBindingSchema = z.object({
+    path: z.string().min(1),
 }).strict();
 export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
     name: DatasetNameSchema,
     about: z.string().optional(),
-    workflow: WorkflowIdSchema,
+    method: MethodIdSchema,
+    workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+    method_origin: z.object({
+        selected: MethodIdSchema,
+        local_draft: z.boolean().optional(),
+    }).optional(),
     workflow_origin: z.object({
         selected: WorkflowIdSchema,
         local_draft: z.boolean().optional(),
@@ -46,17 +58,15 @@ export const CompiledInterfConfigSchema = z.object({
     source: z.object({
         path: z.string(),
         control_path: z.string().optional(),
-        dataset_path: z.string(),
+        preparation_path: z.string().optional(),
+        source_folder_path: z.string().optional(),
+        dataset_path: z.string().optional(),
     }),
 }).passthrough();
 export const InterfConfigSchema = CompiledInterfConfigSchema;
 export const SourceFolderConfigSchema = z.object({
+    source_folder: SourceFolderBindingSchema.optional(),
+    preparations: z.array(SourcePreparationConfigSchema).default([]),
+    // Legacy config array. Read for compatibility; new writes use `preparations`.
     datasets: z.array(SourceDatasetConfigSchema).optional(),
-}).strict().superRefine((value, ctx) => {
-    if ((value.datasets?.length ?? 0) === 0) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Interf project config needs at least one dataset.",
-        });
-    }
-});
+}).strict();

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,31 +1,44 @@
-import { type InterfConfig, type SourceTruthCheck, type SourceDatasetConfig, type SourceFolderConfig } from "./lib/schema.js";
+import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourceDatasetConfig, type SourcePreparationConfig, 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 fingerprintTruthChecks(checks: SourceTruthCheck[]): string;
+export declare function sourceFolderConfigPath(sourcePath: string): string;
+export declare function resolveSourceFolderConfigPath(sourcePath: string): string;
+export declare function fingerprintReadinessChecks(checks: SourceReadinessCheck[]): string;
 export declare function loadSourceFolderConfig(sourcePath: string): SourceFolderConfig | null;
 export interface WritableSourceProjectConfig {
+    source_folder?: SourceFolderBinding;
+    preparations?: SourcePreparationConfig[];
     datasets?: SourceDatasetConfig[];
 }
-export declare function listSourceDatasetConfigs(config: SourceFolderConfig | null): SourceDatasetConfig[];
+export declare function methodIdForSourcePreparationConfig(preparationConfig: Pick<SourcePreparationConfig, "method" | "workflow"> | null | undefined): string | null;
+export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
+export declare const listSourceDatasetConfigs: typeof listSourcePreparationConfigs;
 export declare function resolveDatasetCompileMaxAttempts(datasetConfig: Pick<SourceDatasetConfig, "max_attempts">, override?: number | null): number | null;
 export declare function resolveDatasetCompileMaxLoops(datasetConfig: Pick<SourceDatasetConfig, "max_loops">, override?: number | null): number | null;
-export declare function getDefaultSourceDatasetConfig(config: SourceFolderConfig | null): SourceDatasetConfig | null;
-export declare function findSourceDatasetConfig(config: SourceFolderConfig | null, datasetName: string): SourceDatasetConfig | null;
+export declare function getDefaultSourcePreparationConfig(config: SourceFolderConfig | null): SourcePreparationConfig | null;
+export declare const getDefaultSourceDatasetConfig: typeof getDefaultSourcePreparationConfig;
+export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
+export declare const findSourceDatasetConfig: typeof findSourcePreparationConfig;
+export declare function configuredSourceFolderPath(config: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
+export declare function resolveConfiguredSourceFolderPath(sourcePath: string, config?: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
 export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceProjectConfig): void;
-export declare function appendSourceDatasetChecks(sourcePath: string, datasetName: string, checks: SourceTruthCheck[]): void;
-export declare function upsertSourceDatasetConfig(sourcePath: string, datasetConfig: SourceDatasetConfig, options?: {
+export declare function appendSourceDatasetChecks(sourcePath: string, preparationName: string, checks: SourceReadinessCheck[]): void;
+export declare const appendSourcePreparationChecks: typeof appendSourceDatasetChecks;
+export declare function upsertSourceDatasetConfig(sourcePath: string, preparationConfig: SourcePreparationConfig, options?: {
     matchName?: string;
 }): void;
+export declare const upsertSourcePreparationConfig: typeof upsertSourceDatasetConfig;
 export declare function compiledMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
 export declare function compiledMaxLoops(maxLoops: number | null | undefined): number | undefined;
-export declare function sourceDatasetConfigFromInterfConfig(config: InterfConfig, datasetPath?: string): SourceDatasetConfig;
-export declare function loadCompiledDatasetConfig(compiledPath: string): SourceDatasetConfig | null;
+export declare function sourceDatasetConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
+export declare function loadCompiledDatasetConfig(compiledPath: string): SourcePreparationConfig | null;
 export declare function saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
-export declare function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath: string, datasetConfig: SourceDatasetConfig): InterfConfig;
+export declare function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath: string, datasetConfig: SourcePreparationConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
     sourcePath: string;
     targetName?: string | null;
@@ -35,4 +48,5 @@ export declare function buildTestSpecFromCompiledDatasetConfig(options: {
     compiledPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function resolveSourceDatasetPath(projectPath: string, datasetConfig: Pick<SourceDatasetConfig, "path">): string;
+export declare function resolveSourceDatasetPath(projectPath: string, datasetConfig: Pick<SourcePreparationConfig, "path">): string;
+export declare const resolveSourcePreparationPath: typeof resolveSourceDatasetPath;