@interf/compiler 0.7.2 → 0.9.1

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

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
 import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
@@ -8,13 +8,21 @@ import { readJsonFileWithSchema } from "../shared/parse.js";
 import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.js";
 import { slugify } from "../shared/naming.js";
-import { assertPathWithinRoot } from "../shared/path-guards.js";
+import { assertPathWithinRoot, isPathWithinRoot } 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) {
-    return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
+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);
 }
-function normalizeTruthChecks(cases) {
+export function resolveSourceFolderConfigPath(sourcePath) {
+    return sourceFolderConfigPath(sourcePath);
+}
+function readSourceFolderConfigFile(filePath) {
+    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
+}
+function normalizeReadinessChecks(cases) {
     const seen = new Set();
     return cases.map((caseSpec, index) => {
         const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
@@ -34,7 +42,7 @@ function normalizeTruthChecks(cases) {
         };
     });
 }
-export function fingerprintTruthChecks(checks) {
+export function fingerprintReadinessChecks(checks) {
     const normalized = checks.map((check) => ({
         question: check.question.trim(),
         ...(check.answer ? { answer: check.answer.trim() } : {}),
@@ -47,14 +55,29 @@ 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 methodIdForSourcePreparationConfig(preparationConfig) {
+    return preparationConfig?.method ?? preparationConfig?.workflow ?? null;
+}
+function normalizeSourcePreparationConfig(preparationConfig) {
+    const method = methodIdForSourcePreparationConfig(preparationConfig);
+    return {
+        ...preparationConfig,
+        ...(method ? { method } : {}),
+    };
 }
-export function listSourceDatasetConfigs(config) {
-    return config?.datasets ?? [];
+export function listSourcePreparationConfigs(config) {
+    const explicitPreparations = config?.preparations ?? [];
+    const preparations = explicitPreparations.length > 0
+        ? explicitPreparations
+        : config?.datasets ?? [];
+    return preparations.map((preparation) => normalizeSourcePreparationConfig(preparation));
 }
+export const listSourceDatasetConfigs = listSourcePreparationConfigs;
 export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
     const configured = override ?? datasetConfig.max_attempts ?? null;
     if (configured == null)
@@ -73,71 +96,98 @@ export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
         return 1;
     return Math.min(3, normalized);
 }
-export function getDefaultSourceDatasetConfig(config) {
-    const datasets = listSourceDatasetConfigs(config);
-    return datasets[0] ?? null;
+export function getDefaultSourcePreparationConfig(config) {
+    const preparations = listSourcePreparationConfigs(config);
+    return preparations[0] ?? null;
 }
-export function findSourceDatasetConfig(config, datasetName) {
-    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
+export const getDefaultSourceDatasetConfig = getDefaultSourcePreparationConfig;
+export function findSourcePreparationConfig(config, preparationName) {
+    return listSourcePreparationConfigs(config).find((preparation) => preparation.name === preparationName) ?? null;
+}
+export const findSourceDatasetConfig = findSourcePreparationConfig;
+export function configuredSourceFolderPath(config) {
+    return config?.source_folder?.path ?? null;
+}
+export function resolveConfiguredSourceFolderPath(sourcePath, config = loadSourceFolderConfig(sourcePath)) {
+    const configuredPath = configuredSourceFolderPath(config);
+    return configuredPath ? resolve(sourcePath, configuredPath) : null;
 }
 function toWritableSourceProjectConfig(config) {
-    const datasets = config?.datasets ?? [];
-    if (datasets.length > 0) {
+    const explicitPreparations = config?.preparations ?? [];
+    const preparations = explicitPreparations.length > 0
+        ? explicitPreparations
+        : config?.datasets ?? [];
+    const sourceFolder = config?.source_folder;
+    if (preparations.length > 0) {
         return {
-            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
+            ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+            preparations: preparations.map((preparation) => toWritableSourcePreparationConfig(preparation)),
         };
     }
-    return {};
+    return {
+        ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+        preparations: [],
+    };
 }
-function toWritableSourceDatasetConfig(dataset) {
+function toWritableSourcePreparationConfig(preparation) {
+    const method = methodIdForSourcePreparationConfig(preparation);
     return {
-        name: dataset.name,
-        path: dataset.path,
-        ...(dataset.about ? { about: dataset.about } : {}),
-        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
-        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
-        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
-        checks: dataset.checks,
+        name: preparation.name,
+        path: preparation.path,
+        ...(preparation.about ? { about: preparation.about } : {}),
+        ...(method && method !== "interf" ? { method } : {}),
+        ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
+        ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
+        checks: preparation.checks,
     };
 }
+const toWritableSourceDatasetConfig = toWritableSourcePreparationConfig;
 export function saveSourceFolderConfig(sourcePath, config) {
-    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
+    const existing = loadSourceFolderConfig(sourcePath);
+    const mergedConfig = {
+        ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
+        ...config,
+    };
+    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
+    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
 }
-export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
+export function appendSourceDatasetChecks(sourcePath, preparationName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const currentDataset = findSourceDatasetConfig(existing, datasetName);
-    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
-    const currentChecks = currentDataset?.checks ?? [];
-    const nextDataset = {
-        ...toWritableSourceDatasetConfig(currentDataset ?? {
-            name: datasetName,
-            path: `./${datasetName}`,
+    const currentPreparation = findSourcePreparationConfig(existing, preparationName);
+    const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
+    const currentChecks = currentPreparation?.checks ?? [];
+    const nextPreparation = {
+        ...toWritableSourcePreparationConfig(currentPreparation ?? {
+            name: preparationName,
+            path: `./${preparationName}`,
             checks: [],
         }),
         checks: [...currentChecks, ...checks],
     };
     saveSourceFolderConfig(sourcePath, {
-        datasets: [
-            nextDataset,
-            ...otherDatasets,
+        preparations: [
+            nextPreparation,
+            ...otherPreparations,
         ],
     });
 }
-export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
+export const appendSourcePreparationChecks = appendSourceDatasetChecks;
+export function upsertSourceDatasetConfig(sourcePath, preparationConfig, options = {}) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const datasets = listSourceDatasetConfigs(existing);
-    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
-    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
+    const preparations = listSourcePreparationConfigs(existing);
+    const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = preparations.findIndex((entry) => candidateNames.includes(entry.name));
     if (existingIndex >= 0) {
-        datasets[existingIndex] = datasetConfig;
+        preparations[existingIndex] = normalizeSourcePreparationConfig(preparationConfig);
     }
     else {
-        datasets.push(datasetConfig);
+        preparations.push(normalizeSourcePreparationConfig(preparationConfig));
     }
     saveSourceFolderConfig(sourcePath, {
-        datasets,
+        preparations,
     });
 }
+export const upsertSourcePreparationConfig = upsertSourceDatasetConfig;
 export function compiledMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
@@ -148,12 +198,13 @@ export function compiledMaxLoops(maxLoops) {
         return undefined;
     return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
 }
-export function sourceDatasetConfigFromInterfConfig(config, datasetPath = `./${config.name}`) {
+export function sourceDatasetConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
+    const method = config.method ?? config.workflow;
     return {
         name: config.name,
-        path: datasetPath,
+        path: preparationPath,
         ...(config.about ? { about: config.about } : {}),
-        ...(config.workflow ? { workflow: config.workflow } : {}),
+        ...(method ? { method } : {}),
         ...(typeof config.max_attempts === "number"
             ? { max_attempts: config.max_attempts }
             : {}),
@@ -168,14 +219,27 @@ export function loadCompiledDatasetConfig(compiledPath) {
     if (!config)
         return null;
     const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const configuredDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(projectPath));
-    const fallbackDatasetPath = configuredDatasets.length === 1
-        ? configuredDatasets[0].path
+    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(projectPath));
+    const defaultPreparationPath = configuredPreparations.length === 1
+        ? configuredPreparations[0].path
         : `./${config.name}`;
-    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
-        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled context source path")).split(sep).join("/") || fallbackDatasetPath
-        : fallbackDatasetPath;
-    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
+    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;
+    const preparationPath = sourceBinding
+        ? (() => {
+            const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
+            if (!isPathWithinRoot(projectPath, sourceAbsolutePath)) {
+                return sourceAbsolutePath;
+            }
+            return relative(projectPath, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
+        })()
+        : defaultPreparationPath;
+    return sourceDatasetConfigFromInterfConfig(config, preparationPath);
 }
 export function saveCompiledInterfConfig(compiledPath, config) {
     mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
@@ -185,17 +249,17 @@ export function saveCompiledInterfConfig(compiledPath, config) {
 export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig) {
     const current = readInterfConfig(compiledPath);
     const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const datasetAbsolutePath = resolve(projectPath, datasetConfig.path);
+    const datasetAbsolutePath = resolveSourceDatasetPath(projectPath, datasetConfig);
     const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
-    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
-    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
-    const workflowOrigin = workflowChanged || !current?.workflow_origin
+    const methodId = methodIdForSourcePreparationConfig(datasetConfig) ?? current?.method ?? current?.workflow ?? "interf";
+    const methodChanged = current?.method !== undefined && current.method !== methodId;
+    const methodOrigin = methodChanged || !current?.method_origin
         ? {
-            selected: workflowId,
+            selected: methodId,
             local_draft: false,
         }
-        : current.workflow_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+        : current.method_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, method: _ignoredMethod, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, method_origin: _ignoredMethodOrigin, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
     const nextConfig = {
         ...passthrough,
         ...(!current ? {
@@ -207,7 +271,7 @@ export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, da
         type: "compiled",
         name: datasetConfig.name,
         ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
-        workflow: workflowId,
+        method: methodId,
         ...(typeof datasetConfig.max_attempts === "number"
             ? { max_attempts: datasetConfig.max_attempts }
             : {}),
@@ -215,17 +279,17 @@ export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, da
             ? { max_loops: datasetConfig.max_loops }
             : {}),
         checks: datasetConfig.checks,
-        workflow_origin: workflowOrigin,
+        method_origin: methodOrigin,
         source: {
             path: current?.source?.path ?? "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: datasetRelativePath,
+            preparation_path: datasetRelativePath,
         },
     };
     const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
-    if (workflowChanged) {
+    if (methodChanged) {
         const sourcePath = projectPath;
-        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+        const selectedWorkflow = getCompiledWorkflow(methodId, { sourcePath });
         seedCompiledWorkflowPackage({
             compiledPath,
             sourcePath,
@@ -244,8 +308,8 @@ function buildLoadedTestSpec(options) {
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
-        description: options.about ?? options.fallbackDescription,
-        cases: normalizeTruthChecks(options.checks),
+        description: options.about ?? options.defaultDescription,
+        cases: normalizeReadinessChecks(options.checks),
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
@@ -253,17 +317,17 @@ export function buildTestSpecFromSourceFolderConfig(options) {
     const config = loadSourceFolderConfig(sourcePath);
     if (!config)
         return null;
-    const datasets = listSourceDatasetConfigs(config);
-    if (datasets.length === 0)
+    const preparations = listSourcePreparationConfigs(config);
+    if (preparations.length === 0)
         return null;
     const match = targetName
-        ? datasets.find((entry) => entry.name === targetName)
-        : datasets.length === 1
-            ? datasets[0]
-            : getDefaultSourceDatasetConfig(config);
+        ? preparations.find((entry) => entry.name === targetName)
+        : preparations.length === 1
+            ? preparations[0]
+            : getDefaultSourcePreparationConfig(config);
     if (!match)
         return null;
-    const configPath = sourceConfigPath(sourcePath);
+    const configPath = resolveSourceFolderConfigPath(sourcePath);
     return buildLoadedTestSpec({
         id: match.id,
         name: match.name,
@@ -271,9 +335,9 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         checks: match.checks,
         targetType,
         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}`,
+            ? `${configPath}#preparations/${match.name}:source-files`
+            : `${configPath}#preparations/${match.name}:portable-context`,
+        defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
     });
 }
 export function buildTestSpecFromCompiledDatasetConfig(options) {
@@ -290,9 +354,15 @@ export function buildTestSpecFromCompiledDatasetConfig(options) {
         filePath: targetType === "raw"
             ? `${configPath}#checks:file-as-is`
             : `${configPath}#checks:compiled`,
-        fallbackDescription: "Derived from checks in the compiled context config.",
+        defaultDescription: "Derived from checks in the compiled context config.",
     });
 }
 export function resolveSourceDatasetPath(projectPath, datasetConfig) {
-    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path), "Dataset path");
+    const configuredPath = datasetConfig.path.trim();
+    const resolvedPath = resolve(projectPath, configuredPath);
+    if (isAbsolute(configuredPath)) {
+        return resolvedPath;
+    }
+    return assertPathWithinRoot(projectPath, resolvedPath, "Source folder path");
 }
+export const resolveSourcePreparationPath = resolveSourceDatasetPath;

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

@@ -0,0 +1,11 @@
+export declare function listVisibleSourceFolders(projectPath: string): string[];
+export declare function isReservedSourceDatasetPath(relativePath: string): boolean;
+export declare function normalizeSourceDatasetPathForConfig(projectPath: string, value: string): string;
+export declare function defaultDatasetNameForPath(datasetPath: string): string;
+export declare function findSingleSourceFolderCandidate(projectPath: string): string | null;
+export declare function listSourceFolderChoices(projectPath?: string): Array<{
+    value: string;
+    label: string;
+    hint: string;
+}>;
+export declare function defaultSourceDatasetPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;

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

@@ -0,0 +1,110 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { slugify } from "../shared/naming.js";
+import { resolveSourceDatasetPath } from "./source-config.js";
+import { isPathWithinRoot } from "../shared/path-guards.js";
+const DEFAULT_DATASET_NAME = "dataset1";
+const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
+    ".DS_Store",
+    ".git",
+    ".interf",
+    "interf",
+    "interf.json",
+    "node_modules",
+]);
+export function listVisibleSourceFolders(projectPath) {
+    let rootEntries = [];
+    try {
+        rootEntries = readdirSync(projectPath);
+    }
+    catch {
+        return [];
+    }
+    const visibleEntries = rootEntries.filter((entry) => (!IGNORED_SOURCE_FOLDER_ENTRIES.has(entry) && !entry.startsWith(".")));
+    const visibleDirectories = [];
+    for (const entry of visibleEntries) {
+        try {
+            const entryPath = join(projectPath, entry);
+            if (statSync(entryPath).isDirectory()) {
+                visibleDirectories.push(entry);
+            }
+        }
+        catch {
+            // Ignore unreadable entries.
+        }
+    }
+    return visibleDirectories.sort((left, right) => left.localeCompare(right));
+}
+export function isReservedSourceDatasetPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
+    return normalized === "interf" ||
+        normalized.startsWith("interf/") ||
+        normalized === ".interf" ||
+        normalized.startsWith(".interf/");
+}
+export function normalizeSourceDatasetPathForConfig(projectPath, value) {
+    const trimmedValue = value.trim();
+    const resolvedPath = resolveSourceDatasetPath(projectPath, { path: trimmedValue });
+    const relativePath = relative(projectPath, resolvedPath).split(sep).join("/") || ".";
+    if (relativePath === ".") {
+        throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
+    }
+    if (isAbsolute(trimmedValue) && !isPathWithinRoot(projectPath, resolvedPath)) {
+        if (!existsSync(resolvedPath)) {
+            throw new Error("Pick an existing source folder.");
+        }
+        if (!statSync(resolvedPath).isDirectory()) {
+            throw new Error("Source folder must be a directory.");
+        }
+        return resolvedPath;
+    }
+    if (isReservedSourceDatasetPath(relativePath)) {
+        throw new Error("Pick an existing source folder, not `interf/` or `.interf/`.");
+    }
+    if (!existsSync(resolvedPath)) {
+        throw new Error("Pick an existing source folder.");
+    }
+    if (!statSync(resolvedPath).isDirectory()) {
+        throw new Error("Source folder must be a directory.");
+    }
+    return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+}
+export function defaultDatasetNameForPath(datasetPath) {
+    const segments = datasetPath
+        .replace(/\\/g, "/")
+        .replace(/\/+$/g, "")
+        .split("/")
+        .filter((segment) => segment.length > 0 && segment !== ".");
+    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_DATASET_NAME;
+}
+export function findSingleSourceFolderCandidate(projectPath) {
+    const visibleDirectories = listVisibleSourceFolders(projectPath);
+    if (visibleDirectories.length !== 1) {
+        return null;
+    }
+    return `./${visibleDirectories[0]}`;
+}
+export function listSourceFolderChoices(projectPath = process.cwd()) {
+    return listVisibleSourceFolders(projectPath).map((entry) => ({
+        value: `./${entry}`,
+        label: entry,
+        hint: `Use ./${entry} as the source folder`,
+    }));
+}
+export function defaultSourceDatasetPathForPrompt(name, introStyle, projectPath = process.cwd()) {
+    const namedFolderPath = join(projectPath, name);
+    if (existsSync(namedFolderPath)) {
+        try {
+            if (statSync(namedFolderPath).isDirectory()) {
+                return `./${name}`;
+            }
+        }
+        catch {
+            // Fall through to the normal default.
+        }
+    }
+    if (introStyle === "first") {
+        return findSingleSourceFolderCandidate(projectPath) ?? `./${name}`;
+    }
+    return `./${name}`;
+}

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

@@ -201,9 +201,9 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this portable context.",
             "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the workflow-declared context outputs before raw fallback.",
-            "This sandbox is self-contained: the copied portable context has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
-            "The original project root is intentionally absent from this sandbox. Work only from this sandboxed compiled context and its embedded raw files.",
+            "Prefer the workflow-declared context outputs before consulting `raw/`.",
+            "This sandbox is self-contained: the copied portable context has sanitized source files under `raw/` via `.interf/interf.json` `source.path`.",
+            "The original control plane folder is intentionally absent from this sandbox. Work only from this sandboxed compiled context and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
@@ -211,14 +211,14 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Use the local native `interf-query` skill available in this shell.",
             "There is no compiled context in this sandbox.",
             "Answer only from `raw/` inside this shell.",
-            "The original project root is intentionally absent from this sandbox.",
+            "The original control plane folder is intentionally absent from this sandbox.",
         ];
     return [
         ...header,
         "Emit only STATUS:, DONE:, BLOCKED:, or ERROR: lines.",
         "Do not ask follow-up questions.",
         `Write the answer to ${JSON.stringify(answerPath)}.`,
-        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_raw_fallback, answer_summary.`,
+        `Write the trace to ${JSON.stringify(tracePath)} with keys: case_id, target, artifacts_consulted, raw_paths_read, used_source_files, answer_summary.`,
         `Set \`case_id\` to ${JSON.stringify(testCase.id)}.`,
         `Set \`target\` to ${JSON.stringify(target.type)}.`,
         `Question: ${testCase.question}`,

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

@@ -10,7 +10,8 @@ export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
 function isDatasetTestsRootPath(artifactRootPath) {
-    return basename(dirname(artifactRootPath)) === "tests";
+    return basename(artifactRootPath) === "tests" &&
+        basename(dirname(artifactRootPath)) === ".interf";
 }
 export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
@@ -19,7 +20,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 +32,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.d.ts

@@ -1,7 +1,6 @@
 import type { WorkflowExecutor } from "../agents/lib/executors.js";
 import { validateWorkflowPackage } from "../workflow-package/local-workflows.js";
-import { type WorkflowReporter } from "../compiler/workflows.js";
-import type { SourceTruthCheck } from "../project-model/lib/schema.js";
+import type { SourceReadinessCheck } from "../project-model/lib/schema.js";
 export interface WorkflowAuthoringRunResult {
     status: "updated" | "no-change" | "invalid" | "executor-failed";
     changed: boolean;
@@ -13,14 +12,13 @@ export interface WorkflowAuthoringRunResult {
 export declare function runWorkflowAuthoringDraft(options: {
     sourcePath: string;
     datasetPath: string;
-    baseWorkflowId: string;
+    baseWorkflowId?: string;
     workflowId: string;
     label: string;
     hint: string;
     taskPrompt: string;
-    checks?: SourceTruthCheck[];
+    checks?: SourceReadinessCheck[];
     executor: WorkflowExecutor;
-    preparePreview?: boolean;
-    previewReporter?: WorkflowReporter | null;
+    onStatus?: (line: string) => void;
 }): Promise<WorkflowAuthoringRunResult>;
 export declare function resolveWorkflowDraftPath(sourcePath: string, workflowId: string): string;