@interf/compiler 0.9.1 → 0.9.4

package/dist/cli/commands/init.js

@@ -1,19 +1,34 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, isAbsolute, relative, resolve } from "node:path";
 import { assertCompiledContainer, detectInterf, ensurePortableContextScaffold, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_PATH, configuredSourceFolderPath, loadSourceFolderConfig, resolveConfiguredSourceFolderPath, saveSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
-import { defaultDatasetNameForPath, } from "../../packages/project-model/source-folders.js";
-import { DEFAULT_COMPILED_NAME, describeCompileLoopSelection, listDatasetFolderChoices, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { chooseOrCreateCompiledWorkflowForDataset, createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { seedLocalDefaultWorkflow } from "../../packages/workflow-package/local-workflows.js";
-import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, } from "./compiled-flow.js";
+import { SOURCE_FOLDER_CONFIG_PATH, configuredSourceFolderPath, loadSourceFolderConfig, resolveConfiguredSourceFolderPath, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../../packages/project-model/source-config.js";
+import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
+import { DEFAULT_PREPARATION_NAME, describeCompileLoopSelection, listSourceFolderChoices, promptSingleCompiledConfig, } from "./source-config-wizard.js";
+import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
+import { seedLocalDefaultMethod } from "../../packages/method-package/local-methods.js";
+import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedPreparationEntries, } from "./compiled-flow.js";
 import { readCurrentSavedTestComparison, } from "./test-flow.js";
 import { runCompileCommand } from "./compile.js";
 import { runTestCommand } from "./test.js";
 import { defaultInterfInstanceRoot, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
 import { runWebCommand } from "./web.js";
+function displayPath(path) {
+    const resolvedPath = resolve(path);
+    const cwd = process.cwd();
+    if (resolvedPath === cwd)
+        return ".";
+    if (isPathInside(cwd, resolvedPath))
+        return `./${relative(cwd, resolvedPath)}`;
+    const home = homedir();
+    if (resolvedPath === home)
+        return "~";
+    if (isPathInside(home, resolvedPath))
+        return `~/${relative(home, resolvedPath)}`;
+    return resolvedPath;
+}
 function isPathInside(parentPath, childPath) {
     const relativePath = relative(parentPath, childPath);
     return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
@@ -45,7 +60,7 @@ function normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, input) {
     return controlPath;
 }
 async function promptSourceFolderForInstance(cwd) {
-    const folderChoices = listDatasetFolderChoices(cwd);
+    const folderChoices = listSourceFolderChoices(cwd);
     const selected = await p.select({
         message: "Which Source Folder should Interf prepare?",
         options: [
@@ -119,13 +134,11 @@ async function setupInterfInstance(cwd) {
         source_folder: { path: sourceFolderConfigPath },
         preparations: [],
     });
-    const seeded = seedLocalDefaultWorkflow({ sourcePath: controlPath });
-    p.log.info(`Source Folder: ${sourceFolderPath}`);
-    p.log.info(`Interf Workspace: ${controlPath}`);
-    p.log.info(`Source Folder path in Interf config: ${sourceFolderConfigPath}`);
-    if (!seeded.alreadyExisted) {
-        p.log.info(`Copied built-in Method package to interf/methods/${seeded.workflowId}/. Inspect or fork it anytime.`);
-    }
+    const seeded = seedLocalDefaultMethod({ sourcePath: controlPath });
+    p.log.info(`Source Folder: ${displayPath(sourceFolderPath)}`);
+    p.log.info(`Interf Workspace: ${displayPath(controlPath)}`);
+    if (!seeded.alreadyExisted)
+        p.log.info(`Method: ${seeded.methodId}`);
     return {
         sourceFolderPath,
         controlPath,
@@ -134,7 +147,7 @@ async function setupInterfInstance(cwd) {
 }
 async function promptEmptyInstanceAction() {
     const selected = await p.select({
-        message: "What do you want to do next?",
+        message: "What next?",
         options: [
             {
                 value: "web",
@@ -175,29 +188,30 @@ export function currentRunTargetStatus(rows, target) {
         return "mixed";
     return "fail";
 }
-function describeSavedReadinessChecks(dataset) {
-    const count = dataset.checks.length;
+function describeSavedReadinessChecks(preparation) {
+    const count = preparation.checks.length;
     if (count === 0)
-        return "No readiness checks yet";
+        return "no checks";
     return `${count} readiness check${count === 1 ? "" : "s"}`;
 }
-function printDatasetSummary(options) {
+function printPreparationSummary(options) {
     const compiledConfig = options.builtCompiledPath
         ? readInterfConfig(options.builtCompiledPath)
         : null;
-    const workflowLabel = `${options.dataset.method ?? options.dataset.workflow ?? "interf-default"}${compiledConfig?.workflow_origin?.local_draft === true ? " (local draft)" : ""}`;
-    p.log.info(`Preparation: ${options.dataset.name}`);
-    p.log.info(`Source folder: ${options.dataset.path}`);
-    if (options.dataset.about) {
-        p.log.info(`About: ${options.dataset.about}`);
-    }
-    p.log.info(`Method: ${workflowLabel}`);
-    p.log.info(describeCompileLoopSelection({
-        maxAttempts: options.dataset.max_attempts,
-        maxLoops: options.dataset.max_loops,
-    }));
-    p.log.info(describeSavedReadinessChecks(options.dataset));
-    p.log.info(options.built ? "Portable Context is available." : "Portable Context has not been built yet.");
+    const methodLabel = `${options.preparation.method ?? "interf-default"}${compiledConfig?.method_origin?.local_draft === true ? " (local draft)" : ""}`;
+    const sourceFolderPath = resolve(options.sourcePath, options.preparation.path);
+    p.log.info(`Preparation: ${options.preparation.name} · Method: ${methodLabel}`);
+    if (options.preparation.about) {
+        p.log.info(`Agent work: ${options.preparation.about}`);
+    }
+    p.log.info(`Source Folder: ${displayPath(sourceFolderPath)}`);
+    p.log.info(`Portable Context: ${options.built ? "built" : "not built"} · Readiness: ${describeSavedReadinessChecks(options.preparation)}`);
+    const prepareMode = describeCompileLoopSelection({
+        maxAttempts: options.preparation.max_attempts,
+        maxLoops: options.preparation.max_loops,
+    });
+    if (prepareMode !== "Prepare once.")
+        p.log.info(`Prepare mode: ${prepareMode}`);
     if (options.latestComparison?.raw && options.latestComparison?.compiled) {
         p.log.info(`Latest saved comparison: source files ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}, Portable Context ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
     }
@@ -211,37 +225,45 @@ function printDatasetSummary(options) {
         p.log.info("Saved readiness results are stale for the current checks.");
     }
     if (options.sourcePath !== process.cwd()) {
-        p.log.info(`Interf Workspace: ${options.sourcePath}`);
+        p.log.info(`Interf Workspace: ${displayPath(options.sourcePath)}`);
     }
 }
-async function promptDatasetAction(dataset, built, latestComparison) {
+async function promptPreparationAction(preparation, built, latestComparison) {
     const options = [];
     const hasSavedRawBaseline = Boolean(latestComparison?.raw);
     const latestRawPasses = latestComparison?.raw &&
         latestComparison.raw.passed_cases === latestComparison.raw.total_cases;
     const compileOption = {
         value: "compile",
-        label: built ? "Prepare again and refresh Portable Context" : "Prepare files and write Portable Context (Recommended)",
+        label: built ? "Prepare again" : "Prepare files",
         hint: built
-            ? "Refresh it from the current source files"
-            : dataset.checks.length > 0
+            ? "Refresh Portable Context"
+            : preparation.checks.length > 0
                 ? latestRawPasses
-                    ? "Prepare files for a side-by-side comparison with the latest saved source-files run"
+                    ? "Use the latest source-files baseline"
                     : hasSavedRawBaseline
-                        ? "Some readiness checks still fail on the source files. Prepare files and run the same checks"
-                        : "Run the selected Method and write the output folder agents can use"
-                : "Run the selected Method and create the output folder agents can use",
+                        ? "Run the same readiness checks after prepare"
+                        : "Write Portable Context"
+                : "Write Portable Context",
     };
-    if (dataset.checks.length > 0) {
+    const webOption = {
+        value: "web",
+        label: "Open Interf UI",
+        hint: "Start the local UI and API for this Interf Workspace",
+    };
+    if (built) {
+        options.push(webOption);
+    }
+    if (preparation.checks.length > 0) {
         const testOption = {
             value: "test",
             label: built
-                ? "Run readiness checks on source files and Portable Context (Recommended)"
+                ? "Run readiness checks"
                 : hasSavedRawBaseline
                     ? "Rerun the source-files baseline"
                     : "Measure the source-files baseline",
             hint: built
-                ? "See whether the Portable Context is ready for your agents on the saved checks"
+                ? "Check source files and Portable Context"
                 : hasSavedRawBaseline
                     ? "Refresh the saved source-files baseline on the current readiness checks"
                     : "Optional source-files readiness baseline before Interf builds Portable Context",
@@ -257,33 +279,32 @@ async function promptDatasetAction(dataset, built, latestComparison) {
         options.push(compileOption);
     }
     options.push({
-        value: "dataset",
+        value: "preparation",
         label: "Add another Preparation",
-        hint: "Add a separate folder, focus, or readiness-check set",
+        hint: "Separate source, focus, or checks",
     }, {
         value: "edit",
-        label: "Edit readiness checks and settings",
-        hint: "Update readiness checks, focus, Method, or prepare mode",
+        label: preparation.checks.length === 0 ? "Add readiness checks" : "Edit checks and settings",
+        hint: "Checks, focus, Method, or mode",
     }, {
-        value: "workflow",
+        value: "method",
         label: "Create Method",
-        hint: "Advanced: customize how Interf prepares files",
+        hint: "Custom file processing",
     }, {
         value: "done",
         label: "Done",
         hint: "Exit the wizard",
     });
     const selected = await p.select({
-        message: "What do you want to do next?",
+        message: "What next?",
         options,
     });
     if (p.isCancel(selected))
         return null;
     return selected;
 }
-function printDatasetRecommendation(dataset, built, latestComparison) {
-    if (dataset.checks.length === 0) {
-        p.log.info("No readiness checks yet. You can prepare files first, then add checks when you know what evidence matters.");
+function printPreparationRecommendation(preparation, built, latestComparison) {
+    if (preparation.checks.length === 0) {
         return;
     }
     if (!built) {
@@ -312,7 +333,7 @@ async function promptPostBaselineAction(rows) {
     }
     const compileRecommended = status !== "pass";
     const selected = await p.select({
-        message: "What do you want to do next?",
+        message: "What next?",
         options: [
             {
                 value: "compile",
@@ -350,7 +371,7 @@ async function chooseCompiledForWizard(options) {
     if (options.fixedCompiledName) {
         return findSavedCompiledConfig(options.sourcePath, options.fixedCompiledName);
     }
-    const savedEntries = listSavedCompiledEntries(options.sourcePath);
+    const savedEntries = listSavedPreparationEntries(options.sourcePath);
     if (savedEntries.length === 0)
         return null;
     if (savedEntries.length === 1)
@@ -364,7 +385,7 @@ async function chooseCompiledForWizard(options) {
                 hint: [
                     `path ${entry.config.path}`,
                     entry.config.about ?? describeSavedReadinessChecks(entry.config),
-                    `Method ${entry.config.method ?? entry.config.workflow ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`,
+                    `Method ${entry.config.method ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`,
                     entry.path ? "Portable Context available" : "Portable Context not built yet",
                 ].join(" · "),
             })),
@@ -394,105 +415,107 @@ async function promptCompiledSetup(options) {
     });
     if (!compiledConfig)
         return null;
-    const workflowChoice = await chooseOrCreateCompiledWorkflowForDataset(options.sourcePath, compiledConfig, {
-        currentWorkflowId: options.initial?.workflow ?? "interf-default",
+    const methodChoice = await chooseOrCreateCompiledMethodForPreparation(options.sourcePath, compiledConfig, {
+        currentMethodId: options.initial?.method ?? "interf-default",
         executionProfile: options.executionProfile,
     });
-    if (!workflowChoice || p.isCancel(workflowChoice))
+    if (!methodChoice || p.isCancel(methodChoice))
         return null;
-    const workflowId = String(workflowChoice);
-    const compiledConfigWithWorkflow = {
+    const methodId = String(methodChoice);
+    const compiledConfigWithMethod = {
         ...compiledConfig,
-        method: workflowId,
-        workflow: workflowId,
+        method: methodId,
     };
-    upsertSourceDatasetConfig(options.sourcePath, compiledConfigWithWorkflow, {
+    upsertSourcePreparationConfig(options.sourcePath, compiledConfigWithMethod, {
         ...(options.fixedName ? { matchName: options.fixedName } : {}),
     });
-    const builtCompiledPath = findBuiltCompiledPath(options.sourcePath, compiledConfigWithWorkflow.name);
+    const builtCompiledPath = findBuiltCompiledPath(options.sourcePath, compiledConfigWithMethod.name);
     if (builtCompiledPath) {
-        syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, compiledConfigWithWorkflow);
+        syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, compiledConfigWithMethod);
     }
     else {
-        ensurePortableContextScaffold(options.sourcePath, compiledConfigWithWorkflow.name, compiledConfigWithWorkflow.workflow ?? "interf-default");
+        ensurePortableContextScaffold(options.sourcePath, compiledConfigWithMethod.name, compiledConfigWithMethod.method ?? "interf-default");
     }
     console.log();
     console.log(chalk.green(`  ✓ Saved Preparation in ${SOURCE_FOLDER_CONFIG_PATH}`));
     console.log(chalk.dim(`  Interf Workspace: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Preparation: ${compiledConfigWithWorkflow.name}`));
-    console.log(chalk.dim(`  Source folder: ${compiledConfigWithWorkflow.path}`));
-    console.log(chalk.dim(`  Method: ${workflowId} · interf/methods/${workflowId}/`));
+    console.log(chalk.dim(`  Preparation: ${compiledConfigWithMethod.name}`));
+    console.log(chalk.dim(`  Source folder: ${compiledConfigWithMethod.path}`));
+    console.log(chalk.dim(`  Method: ${methodId} · interf/methods/${methodId}/`));
     console.log(chalk.dim(`  Prepare mode: ${describeCompileLoopSelection({
-        maxAttempts: compiledConfigWithWorkflow.max_attempts,
-        maxLoops: compiledConfigWithWorkflow.max_loops,
+        maxAttempts: compiledConfigWithMethod.max_attempts,
+        maxLoops: compiledConfigWithMethod.max_loops,
     })}`));
-    return compiledConfigWithWorkflow;
+    return compiledConfigWithMethod;
 }
 export async function compileSelectedCompiled(sourcePath, compiledConfig, deps = {}) {
     return (deps.runCompileCommand ?? runCompileCommand)({
         sourcePath,
-        dataset: compiledConfig.name,
-        datasetConfig: compiledConfig,
+        preparation: compiledConfig.name,
+        preparationConfig: compiledConfig,
         skipConfirm: true,
-        skipDatasetBanner: true,
+        skipPreparationBanner: true,
     });
 }
 async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
     const { comparison: latestComparison, stale: latestComparisonStale, } = readCurrentSavedTestComparison({
         projectPath: sourcePath,
-        datasetName: compiledConfig.name,
+        preparationName: compiledConfig.name,
         checks: compiledConfig.checks,
     });
-    printDatasetSummary({
+    printPreparationSummary({
         sourcePath,
-        dataset: compiledConfig,
+        preparation: compiledConfig,
         built: Boolean(builtCompiledPath),
         builtCompiledPath,
         latestComparison,
         latestComparisonStale,
     });
-    printDatasetRecommendation(compiledConfig, Boolean(builtCompiledPath), latestComparison);
-    const action = await promptDatasetAction(compiledConfig, Boolean(builtCompiledPath), latestComparison);
+    printPreparationRecommendation(compiledConfig, Boolean(builtCompiledPath), latestComparison);
+    const action = await promptPreparationAction(compiledConfig, Boolean(builtCompiledPath), latestComparison);
     if (!action)
         return;
     if (action === "done") {
         p.outro(options.justConfigured ? "Saved Preparation." : "Nothing changed.");
         return;
     }
-    if (action === "workflow") {
-        const workflowId = await createWorkflowWizard({
+    if (action === "method") {
+        const methodId = await createMethodWizard({
             sourcePath,
-            datasetContext: {
+            preparationContext: {
                 config: compiledConfig,
-                datasetPath: resolve(sourcePath, compiledConfig.path),
+                sourceFolderPath: resolve(sourcePath, compiledConfig.path),
             },
         });
-        if (typeof workflowId === "string") {
+        if (typeof methodId === "string") {
             const nextConfig = {
                 ...compiledConfig,
-                method: workflowId,
-                workflow: workflowId,
+                method: methodId,
             };
-            upsertSourceDatasetConfig(sourcePath, nextConfig, {
+            upsertSourcePreparationConfig(sourcePath, nextConfig, {
                 matchName: compiledConfig.name,
             });
             const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
             if (builtCompiledPath) {
-                syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+                syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, nextConfig);
             }
             else {
-                ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.workflow ?? "interf-default");
+                ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.method ?? "interf-default");
             }
-            p.log.info(`Assigned Method "${workflowId}" to Preparation "${compiledConfig.name}".`);
+            p.log.info(`Assigned Method "${methodId}" to Preparation "${compiledConfig.name}".`);
             p.log.info("Next: run `interf compile`, then `interf test`.");
         }
         return;
     }
-    if (action === "dataset") {
+    if (action === "web") {
+        await runWebCommand({ "control-path": sourcePath });
+        return;
+    }
+    if (action === "preparation") {
         const nextCompiled = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_COMPILED_NAME },
+            initial: { name: DEFAULT_PREPARATION_NAME },
             introStyle: "additional",
         });
         if (!nextCompiled)
@@ -523,8 +546,8 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         if (builtCompiledPath) {
             const baselineRan = await runTestCommand({
                 sourcePath,
-                dataset: compiledConfig.name,
-                datasetConfig: compiledConfig,
+                preparation: compiledConfig.name,
+                preparationConfig: compiledConfig,
                 target: "both",
             });
             if (!baselineRan) {
@@ -536,9 +559,9 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             const baselineCapture = { result: null };
             const baselineRan = await runTestCommand({
                 sourcePath,
-                dataset: compiledConfig.name,
-                datasetConfig: compiledConfig,
-                target: "raw",
+                preparation: compiledConfig.name,
+                preparationConfig: compiledConfig,
+                target: "source-files",
                 onComplete(result) {
                     baselineCapture.result = result;
                 },
@@ -580,8 +603,8 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         }
         await runTestCommand({
             sourcePath,
-            dataset: compiledConfig.name,
-            datasetConfig: compiledConfig,
+            preparation: compiledConfig.name,
+            preparationConfig: compiledConfig,
             target: "both",
         });
         return;
@@ -607,8 +630,8 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             return;
         await runTestCommand({
             sourcePath,
-            dataset: compiledConfig.name,
-            datasetConfig: compiledConfig,
+            preparation: compiledConfig.name,
+            preparationConfig: compiledConfig,
             target: "both",
         });
         return;
@@ -623,8 +646,6 @@ export const initCommand = {
 };
 export async function runInitCommand() {
     p.intro(chalk.bold("Interf"));
-    p.log.info("Interf prepares data for agent work.");
-    p.log.info("It runs locally to process files, show evidence that your data is ready, and write verifiable outputs as Portable Context for agents.");
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
     let initContext = detected
@@ -636,7 +657,7 @@ export async function runInitCommand() {
         : resolveInterfInstanceContext(cwd);
     let sourcePath = initContext.controlPath;
     if (detected) {
-        p.log.info(`Working from Interf Workspace: ${sourcePath}`);
+        p.log.info(`Interf Workspace: ${displayPath(sourcePath)}`);
     }
     const hasConfig = Boolean(loadSourceFolderConfig(sourcePath));
     let initialSourceFolderPath = initContext.defaultSourceFolderPath;
@@ -655,14 +676,14 @@ export async function runInitCommand() {
         };
     }
     else {
-        const seeded = seedLocalDefaultWorkflow({ sourcePath });
+        const seeded = seedLocalDefaultMethod({ sourcePath });
         if (!seeded.alreadyExisted) {
-            p.log.info(`Copied built-in Method package to interf/methods/${seeded.workflowId}/. Inspect or fork it anytime.`);
+            p.log.info(`Method: ${seeded.methodId}`);
         }
     }
     let currentConfig = loadSourceFolderConfig(sourcePath);
     if (!currentConfig?.source_folder && !detected) {
-        const currentEntries = currentConfig?.preparations ?? currentConfig?.datasets ?? [];
+        const currentEntries = currentConfig?.preparations ?? [];
         if (initialSourceFolderPath && initialSourceFolderConfigPath) {
             saveSourceFolderConfig(sourcePath, {
                 source_folder: { path: initialSourceFolderConfigPath },
@@ -701,7 +722,7 @@ export async function runInitCommand() {
         initialSourceFolderPath = configuredSourcePath;
         initialSourceFolderConfigPath = configuredSourceConfigPath;
     }
-    const savedEntries = listSavedCompiledEntries(sourcePath);
+    const savedEntries = listSavedPreparationEntries(sourcePath);
     if (savedEntries.length === 0) {
         p.log.info("No Preparations yet. Create one when you are ready to describe the agent work.");
         const action = await promptEmptyInstanceAction();
@@ -714,9 +735,9 @@ export async function runInitCommand() {
             return;
         }
         if (action === "method") {
-            const workflowId = await createWorkflowWizard({ sourcePath });
-            if (typeof workflowId === "string") {
-                p.outro(`Saved Method "${workflowId}". Next: create a Preparation and assign this Method.`);
+            const methodId = await createMethodWizard({ sourcePath });
+            if (typeof methodId === "string") {
+                p.outro(`Saved Method "${methodId}". Next: create a Preparation and assign this Method.`);
             }
             return;
         }
@@ -724,10 +745,10 @@ export async function runInitCommand() {
             sourcePath,
             initial: initialSourceFolderPath && initialSourceFolderConfigPath
                 ? {
-                    name: defaultDatasetNameForPath(initialSourceFolderPath),
+                    name: defaultPreparationNameForPath(initialSourceFolderPath),
                     path: initialSourceFolderConfigPath,
                 }
-                : { name: DEFAULT_COMPILED_NAME },
+                : { name: DEFAULT_PREPARATION_NAME },
             ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "first",
         });
@@ -747,10 +768,10 @@ export async function runInitCommand() {
             sourcePath,
             initial: initialSourceFolderPath && initialSourceFolderConfigPath
                 ? {
-                    name: defaultDatasetNameForPath(initialSourceFolderPath),
+                    name: defaultPreparationNameForPath(initialSourceFolderPath),
                     path: initialSourceFolderConfigPath,
                 }
-                : { name: DEFAULT_COMPILED_NAME },
+                : { name: DEFAULT_PREPARATION_NAME },
             ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "additional",
         });

package/dist/cli/commands/list.js

@@ -1,29 +1,30 @@
 import chalk from "chalk";
 import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { listSavedCompiledEntries } from "./compiled-flow.js";
+import { listSavedPreparationEntries } from "./compiled-flow.js";
 import { resolveCommandControlPath } from "./control-path.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
 export const listCommand = {
     command: "list",
     describe: "List saved Preparations in this Source Folder",
     handler: async () => {
         const detected = detectInterf(process.cwd());
         const sourcePath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
-        const datasets = listSavedCompiledEntries(sourcePath);
-        if (datasets.length === 0) {
+        const preparations = listSavedPreparationEntries(sourcePath);
+        if (preparations.length === 0) {
             console.log(chalk.dim("  Nothing found. Start with `interf` or `interf init` to define a Preparation and save readiness checks."));
             return;
         }
         console.log();
         console.log(chalk.bold("  Saved Preparations"));
         console.log();
-        for (const dataset of datasets) {
-            console.log(`  ${dataset.config.name}`);
-            if (dataset.config.about) {
-                console.log(chalk.dim(`    task: ${dataset.config.about}`));
+        for (const preparation of preparations) {
+            console.log(`  ${preparation.config.name}`);
+            if (preparation.config.about) {
+                console.log(chalk.dim(`    task: ${preparation.config.about}`));
             }
-            console.log(chalk.dim(`    ${dataset.path ? "Portable Context available" : "Portable Context not built yet"} · Source Folder: ${dataset.config.path}`));
-            console.log(chalk.dim(`    Method: ${dataset.config.method ?? dataset.config.workflow ?? "interf-default"}${dataset.localDraft ? " (local draft)" : ""}`));
-            console.log(chalk.dim(`    readiness checks: ${dataset.config.checks.length}`));
+            console.log(chalk.dim(`    ${preparation.path ? "Portable Context available" : "Portable Context not built yet"} · Source Folder: ${preparation.config.path}`));
+            console.log(chalk.dim(`    Method: ${resolveMethodId(preparation.config)}${preparation.localDraft ? " (local draft)" : ""}`));
+            console.log(chalk.dim(`    readiness checks: ${preparation.config.checks.length}`));
         }
     },
 };

package/dist/cli/commands/preparation-selection.d.ts

@@ -1,6 +1,6 @@
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
 export declare function resolveConfiguredPreparationSelection(options: {
     sourcePath: string;
     requestedPreparationName?: string | null;
-    hintedPreparationConfig?: SourceDatasetConfig | null;
-}): SourceDatasetConfig | null;
+    hintedPreparationConfig?: SourcePreparationConfig | null;
+}): SourcePreparationConfig | null;

package/dist/cli/commands/source-config-wizard.d.ts

@@ -1,9 +1,9 @@
-import { type SourceDatasetConfig, type SourceReadinessCheck } from "../../packages/project-model/index.js";
-export declare const DEFAULT_COMPILED_NAME = "dataset1";
+import { type SourcePreparationConfig, type SourceReadinessCheck } from "../../packages/project-model/index.js";
+export declare const DEFAULT_PREPARATION_NAME = "default";
 export declare const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
 export declare const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
 export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
-export declare const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
+export declare const DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER = "./source-files";
 export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export declare const DEFAULT_SELF_IMPROVING_LOOPS = 3;
 export type CompileLoopMode = "once" | "retry" | "self-improving";
@@ -11,14 +11,14 @@ export interface CompileLoopSelection {
     max_attempts?: number;
     max_loops?: number;
 }
-export declare function normalizeDatasetPathForConfig(projectPath: string, value: string): string;
-export declare function listDatasetFolderChoices(cwd?: string): Array<{
+export declare function normalizeSourceFolderPathForConfig(projectPath: string, value: string): string;
+export declare function listSourceFolderChoices(cwd?: string): Array<{
     value: string;
     label: string;
     hint: string;
 }>;
-export declare function defaultDatasetPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", cwd?: string): string;
-export declare function datasetAboutPromptMessage(introStyle: "first" | "additional" | "edit"): string;
+export declare function defaultSourceFolderPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", cwd?: string): string;
+export declare function preparationAboutPromptMessage(introStyle: "first" | "additional" | "edit"): string;
 export declare function resolveCompileLoopMode(maxAttempts?: number | null, maxLoops?: number | null): CompileLoopMode;
 export declare function describeCompileLoopSelection(options: {
     maxAttempts?: number | null;
@@ -44,9 +44,9 @@ export declare function promptCompileLoopSelection(options: {
 }): Promise<CompileLoopSelection | null>;
 export declare function promptSingleCompiledConfig(options?: {
     projectPath?: string;
-    initial?: Partial<Pick<SourceDatasetConfig, "name" | "path" | "about" | "checks" | "max_attempts" | "max_loops">>;
+    initial?: Partial<Pick<SourcePreparationConfig, "name" | "path" | "about" | "checks" | "max_attempts" | "max_loops">>;
     fixedName?: string;
     fixedPath?: string;
     skipAboutPrompt?: boolean;
     introStyle?: "first" | "additional" | "edit";
-}): Promise<SourceDatasetConfig | null>;
+}): Promise<SourcePreparationConfig | null>;