@interf/compiler 0.7.3 → 0.9.3

package/dist/cli/commands/init.js

@@ -1,15 +1,180 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { resolve } from "node:path";
-import { detectInterf, ensurePortableContextScaffold, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_PATH, migrateLegacySourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
-import { DEFAULT_COMPILED_NAME, describeCompileLoopSelection, 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 { 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, 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));
+}
+function normalizeSourceFolderInput(cwd, input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Source Folder is required.");
+    }
+    const sourceFolderPath = resolve(cwd, trimmed);
+    if (!existsSync(sourceFolderPath)) {
+        throw new Error("Pick an existing Source Folder.");
+    }
+    if (!statSync(sourceFolderPath).isDirectory()) {
+        throw new Error("Source Folder must be a directory.");
+    }
+    return sourceFolderPath;
+}
+function normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        throw new Error("Interf Workspace folder is required.");
+    }
+    const controlPath = resolve(cwd, trimmed);
+    if (isPathInside(sourceFolderPath, controlPath)) {
+        throw new Error("Choose an Interf Workspace folder outside the Source Folder so Interf does not write generated state into your source files.");
+    }
+    assertCompiledContainer(controlPath);
+    return controlPath;
+}
+async function promptSourceFolderForInstance(cwd) {
+    const folderChoices = listSourceFolderChoices(cwd);
+    const selected = await p.select({
+        message: "Which Source Folder should Interf prepare?",
+        options: [
+            ...folderChoices,
+            {
+                value: "__current__",
+                label: `Use current folder (${basename(cwd)})`,
+                hint: cwd,
+            },
+            {
+                value: "__manual__",
+                label: "Enter a different path",
+                hint: "Use an absolute path or a path relative to this folder",
+            },
+        ],
+        initialValue: folderChoices.length === 1 ? folderChoices[0]?.value : "__current__",
+    });
+    if (p.isCancel(selected))
+        return null;
+    if (selected === "__manual__") {
+        const sourceInput = await p.text({
+            message: "Source Folder path?",
+            placeholder: cwd,
+            initialValue: cwd,
+            validate: (value) => {
+                try {
+                    normalizeSourceFolderInput(cwd, value);
+                    return undefined;
+                }
+                catch (error) {
+                    return error instanceof Error ? error.message : String(error);
+                }
+            },
+        });
+        if (p.isCancel(sourceInput))
+            return null;
+        return normalizeSourceFolderInput(cwd, String(sourceInput));
+    }
+    return normalizeSourceFolderInput(cwd, selected === "__current__" ? "." : String(selected));
+}
+async function promptInterfInstanceFolder(cwd, sourceFolderPath) {
+    const defaultControlPath = defaultInterfInstanceRoot(sourceFolderPath);
+    p.log.info("Interf stores config, Methods, runs, and portable context outside the Source Folder.");
+    const controlInput = await p.text({
+        message: "Where should Interf store this Interf Workspace?",
+        placeholder: defaultControlPath,
+        initialValue: defaultControlPath,
+        validate: (value) => {
+            try {
+                normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, value);
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    });
+    if (p.isCancel(controlInput))
+        return null;
+    return normalizeInterfInstanceFolderInput(cwd, sourceFolderPath, String(controlInput));
+}
+async function setupInterfInstance(cwd) {
+    const sourceFolderPath = await promptSourceFolderForInstance(cwd);
+    if (!sourceFolderPath)
+        return null;
+    const controlPath = await promptInterfInstanceFolder(cwd, sourceFolderPath);
+    if (!controlPath)
+        return null;
+    const sourceFolderConfigPath = relativeSourceFolderPath(controlPath, sourceFolderPath);
+    saveSourceFolderConfig(controlPath, {
+        source_folder: { path: sourceFolderConfigPath },
+        preparations: [],
+    });
+    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,
+        sourceFolderConfigPath,
+    };
+}
+async function promptEmptyInstanceAction() {
+    const selected = await p.select({
+        message: "What next?",
+        options: [
+            {
+                value: "web",
+                label: "Open Interf UI (Recommended)",
+                hint: "Start the local UI and API for this Source Folder",
+            },
+            {
+                value: "preparation",
+                label: "Create Preparation",
+                hint: "Describe the agent work, choose a Method, and save readiness checks",
+            },
+            {
+                value: "method",
+                label: "Create Method",
+                hint: "Create or draft a reusable way to process files",
+            },
+            {
+                value: "done",
+                label: "Done",
+                hint: `Leave the empty Interf Workspace at ${SOURCE_FOLDER_CONFIG_PATH}`,
+            },
+        ],
+    });
+    if (p.isCancel(selected))
+        return null;
+    return selected;
+}
 export function currentRunTargetStatus(rows, target) {
     const outcomes = rows
         .map((row) => (target === "raw" ? row.rawOutcome : row.compiledOutcome))
@@ -23,76 +188,85 @@ export function currentRunTargetStatus(rows, target) {
         return "mixed";
     return "fail";
 }
-function describeSavedQuestions(dataset) {
-    const count = dataset.checks.length;
+function describeSavedReadinessChecks(preparation) {
+    const count = preparation.checks.length;
     if (count === 0)
-        return "No questions yet";
-    return `${count} question${count === 1 ? "" : "s"}`;
+        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.workflow ?? "interf"}${compiledConfig?.workflow_origin?.local_draft === true ? " (local draft)" : ""}`;
-    p.log.info(`Dataset: ${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(`Workflow: ${workflowLabel}`);
-    p.log.info(describeCompileLoopSelection({
-        maxAttempts: options.dataset.max_attempts,
-        maxLoops: options.dataset.max_loops,
-    }));
-    p.log.info(describeSavedQuestions(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}.`);
+        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}.`);
     }
     else if (options.latestComparison?.raw) {
         p.log.info(`Latest saved source-files run: ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}.`);
     }
     else if (options.latestComparison?.compiled) {
-        p.log.info(`Latest portable-context run: ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+        p.log.info(`Latest Portable Context run: ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
     }
     else if (options.latestComparisonStale) {
-        p.log.info("Saved test results are stale for the current questions.");
+        p.log.info("Saved readiness results are stale for the current checks.");
     }
     if (options.sourcePath !== process.cwd()) {
-        p.log.info(`Project folder: ${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 ? "Rebuild portable context agents can use" : "Build portable context agents can use (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
-                    ? "Build portable context agents can use for a side-by-side comparison with the latest saved source-files run"
+                    ? "Use the latest source-files baseline"
                     : hasSavedRawBaseline
-                        ? "Some questions still fail on the source files. Build portable context agents can use and compare it on the same questions"
-                        : "Run the selected workflow and write portable context agents can use"
-                : "Build it for agents first, then measure it",
+                        ? "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
-                ? "Compare 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 helps your agents on the saved questions"
+                ? "Check source files and Portable Context"
                 : hasSavedRawBaseline
-                    ? "Refresh the saved source-files baseline on the current questions"
-                    : "Optional benchmark before Interf builds portable context",
+                    ? "Refresh the saved source-files baseline on the current readiness checks"
+                    : "Optional source-files readiness baseline before Interf builds Portable Context",
         };
         if (built) {
             options.push(testOption, compileOption);
@@ -105,46 +279,45 @@ async function promptDatasetAction(dataset, built, latestComparison) {
         options.push(compileOption);
     }
     options.push({
-        value: "dataset",
-        label: "Add another setup",
-        hint: "Add a separate folder, focus, or question set",
+        value: "preparation",
+        label: "Add another Preparation",
+        hint: "Separate source, focus, or checks",
     }, {
         value: "edit",
-        label: "Edit questions and settings",
-        hint: "Update questions, focus, workflow, or compile mode",
+        label: preparation.checks.length === 0 ? "Add readiness checks" : "Edit checks and settings",
+        hint: "Checks, focus, Method, or mode",
     }, {
-        value: "workflow",
-        label: "Create workflow",
-        hint: "Advanced: customize the compile method",
+        value: "method",
+        label: "Create Method",
+        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("Recommended first step: save a few questions for this dataset.");
+function printPreparationRecommendation(preparation, built, latestComparison) {
+    if (preparation.checks.length === 0) {
         return;
     }
     if (!built) {
         if (latestComparison?.raw) {
             p.log.info(latestComparison.raw.passed_cases === latestComparison.raw.total_cases
-                ? `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Build portable context agents can use if you want a side-by-side comparison.`
-                : `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Some questions still fail on the source files. Build portable context agents can use if you want Interf to process this data and compare it on the same questions.`);
+                ? `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Prepare files if you want a side-by-side comparison.`
+                : `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Some readiness checks still fail on the source files. Prepare files if you want Interf to process this data and run the same checks.`);
             return;
         }
-        p.log.info("Recommended first step: choose a workflow and build portable context agents can use.");
+        p.log.info("Recommended first step: choose a Method and prepare files.");
         return;
     }
-    p.log.info("Recommended first step: compare the source-files baseline and portable context.");
+    p.log.info("Recommended first step: compare the source-files baseline and Portable Context.");
 }
 async function promptPostBaselineAction(rows) {
     const status = currentRunTargetStatus(rows, "raw");
@@ -160,33 +333,33 @@ 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",
                 label: compileRecommended
-                    ? "Build portable context agents can use (Recommended)"
-                    : "Build portable context agents can use",
+                    ? "Prepare files and write Portable Context (Recommended)"
+                    : "Prepare files and write Portable Context",
                 hint: compileRecommended
                     ? status === "mixed"
-                        ? "Some selected agents still failed on the source files. Build portable context agents can use and compare it on the same questions"
-                        : "Build portable context agents can use and compare it on the same questions"
-                    : "Build portable context agents can use and compare it on the same questions",
+                        ? "Some selected agents still failed on the source files. Prepare files and run the same readiness checks"
+                        : "Prepare files and run the same readiness checks"
+                    : "Prepare files and run the same readiness checks",
             },
             {
                 value: "edit",
-                label: "Change questions and settings",
-                hint: "Revise the questions or setup settings before the next run",
+                label: "Change readiness checks and settings",
+                hint: "Revise the readiness checks or Preparation settings before the next run",
             },
             {
                 value: "rerun",
                 label: "Rerun the source-files baseline",
-                hint: "Run the same questions again, including different local agents if you want",
+                hint: "Run the same readiness checks again, including different local agents if you want",
             },
             {
                 value: "done",
                 label: "Stop here",
-                hint: "Leave the dataset as-is for now",
+                hint: "Leave the Preparation as-is for now",
             },
         ],
     });
@@ -198,28 +371,28 @@ 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)
         return savedEntries[0]?.config ?? null;
     const selected = await p.select({
-        message: "Which source folder setup do you want to work with?",
+        message: "Which saved Preparation do you want to work with?",
         options: [
             ...savedEntries.map((entry) => ({
                 value: entry.config.name,
                 label: entry.config.name,
                 hint: [
                     `path ${entry.config.path}`,
-                    entry.config.about ?? describeSavedQuestions(entry.config),
-                    `workflow ${entry.config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`,
-                    entry.path ? "built" : "not built yet",
+                    entry.config.about ?? describeSavedReadinessChecks(entry.config),
+                    `Method ${entry.config.method ?? "interf-default"}${entry.localDraft ? " (local draft)" : ""}`,
+                    entry.path ? "Portable Context available" : "Portable Context not built yet",
                 ].join(" · "),
             })),
             {
                 value: "__new__",
-                label: "Add another setup",
-                hint: "Add a separate folder, focus, or question set",
+                label: "Add another Preparation",
+                hint: "Add a separate folder, focus, or readiness-check set",
             },
         ],
     });
@@ -230,111 +403,119 @@ async function chooseCompiledForWizard(options) {
     return findSavedCompiledConfig(options.sourcePath, String(selected));
 }
 async function promptCompiledSetup(options) {
+    const savedConfig = loadSourceFolderConfig(options.sourcePath);
+    const fixedPath = options.fixedPath
+        ?? (options.fixedName ? options.initial?.path : configuredSourceFolderPath(savedConfig) ?? undefined);
     const compiledConfig = await promptSingleCompiledConfig({
         projectPath: options.sourcePath,
         initial: options.initial,
         ...(options.fixedName ? { fixedName: options.fixedName } : {}),
+        ...(fixedPath ? { fixedPath } : {}),
         introStyle: options.introStyle,
     });
     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,
-        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 setup in ${SOURCE_FOLDER_CONFIG_PATH}`));
-    console.log(chalk.dim(`  Project folder: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Setup: ${compiledConfigWithWorkflow.name}`));
-    console.log(chalk.dim(`  Source folder: ${compiledConfigWithWorkflow.path}`));
-    console.log(chalk.dim(`  Workflow: ${workflowId} · interf/workflows/${workflowId}/`));
-    console.log(chalk.dim(`  Compile mode: ${describeCompileLoopSelection({
-        maxAttempts: compiledConfigWithWorkflow.max_attempts,
-        maxLoops: compiledConfigWithWorkflow.max_loops,
+    console.log(chalk.green(`  ✓ Saved Preparation in ${SOURCE_FOLDER_CONFIG_PATH}`));
+    console.log(chalk.dim(`  Interf Workspace: ${options.sourcePath}`));
+    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: 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 dataset setup." : "Nothing changed.");
+        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,
-                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 workflow "${workflowId}" to dataset "${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)
@@ -357,16 +538,16 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     if (action === "test") {
         if (compiledConfig.checks.length === 0) {
             process.exitCode = 1;
-            console.log(chalk.red(`  Setup "${compiledConfig.name}" does not have any questions yet.`));
-            console.log(chalk.dim("  Run `interf`, edit this setup, and add a few questions first."));
+            console.log(chalk.red(`  Preparation "${compiledConfig.name}" does not have any readiness checks yet.`));
+            console.log(chalk.dim("  Run `interf`, edit this Preparation, and add a few readiness checks first."));
             console.log(chalk.dim("  Then rerun `interf test`."));
             return;
         }
         if (builtCompiledPath) {
             const baselineRan = await runTestCommand({
                 sourcePath,
-                dataset: compiledConfig.name,
-                datasetConfig: compiledConfig,
+                preparation: compiledConfig.name,
+                preparationConfig: compiledConfig,
                 target: "both",
             });
             if (!baselineRan) {
@@ -378,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;
                 },
@@ -416,14 +597,14 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             return;
         }
         if (compileResult.testedDuringCompile) {
-            p.log.info("This compile run already checked the portable context on the saved questions.");
+            p.log.info("This prepare run already checked the Portable Context on the saved readiness checks.");
             p.log.info("Run `interf test` later if you want a fresh side-by-side comparison summary.");
             return;
         }
         await runTestCommand({
             sourcePath,
-            dataset: compiledConfig.name,
-            datasetConfig: compiledConfig,
+            preparation: compiledConfig.name,
+            preparationConfig: compiledConfig,
             target: "both",
         });
         return;
@@ -435,22 +616,22 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         if (compiledConfig.checks.length === 0)
             return;
         if (compileResult.testedDuringCompile) {
-            p.log.info("This compile run already checked the portable context on the compile agent.");
+            p.log.info("This prepare run already checked the Portable Context on the compile agent.");
         }
         const runCompiledTest = await p.confirm({
             message: compileResult.testedDuringCompile
-                ? "Run a fresh source-files versus portable-context comparison now?"
+                ? "Run a fresh source-files versus Portable Context comparison now?"
                 : builtCompiledPath
-                    ? "Run source files and portable context on the saved questions now?"
-                    : "Compare source files and portable context on the saved questions now?",
+                    ? "Run readiness checks on source files and Portable Context now?"
+                    : "Run readiness checks on source files and Portable Context now?",
             initialValue: true,
         });
         if (p.isCancel(runCompiledTest) || !runCompiledTest)
             return;
         await runTestCommand({
             sourcePath,
-            dataset: compiledConfig.name,
-            datasetConfig: compiledConfig,
+            preparation: compiledConfig.name,
+            preparationConfig: compiledConfig,
             target: "both",
         });
         return;
@@ -458,33 +639,117 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
 }
 export const initCommand = {
     command: "init",
-    describe: "Open the dataset wizard for this folder",
+    describe: "Set up Interf or open the Preparation wizard",
     handler: async () => {
         await runInitCommand();
     },
 };
 export async function runInitCommand() {
     p.intro(chalk.bold("Interf"));
-    p.log.info("Interf prepares data for agent work.");
-    p.log.info("Run locally, 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);
-    const sourcePath = detected ? resolveSourceControlPath(detected.path) : cwd;
+    let initContext = detected
+        ? {
+            controlPath: resolveSourceControlPath(detected.path),
+            defaultSourceFolderPath: null,
+            defaultPreparationPath: null,
+        }
+        : resolveInterfInstanceContext(cwd);
+    let sourcePath = initContext.controlPath;
     if (detected) {
-        p.log.info(`Working from the project folder: ${sourcePath}`);
+        p.log.info(`Interf Workspace: ${displayPath(sourcePath)}`);
     }
-    if (migrateLegacySourceFolderConfig(sourcePath)) {
-        p.log.info(`Moved saved setup to ${SOURCE_FOLDER_CONFIG_PATH}.`);
+    const hasConfig = Boolean(loadSourceFolderConfig(sourcePath));
+    let initialSourceFolderPath = initContext.defaultSourceFolderPath;
+    let initialSourceFolderConfigPath = initContext.defaultPreparationPath;
+    if (!detected && !hasConfig) {
+        const setup = await setupInterfInstance(cwd);
+        if (!setup)
+            return;
+        sourcePath = setup.controlPath;
+        initialSourceFolderPath = setup.sourceFolderPath;
+        initialSourceFolderConfigPath = setup.sourceFolderConfigPath;
+        initContext = {
+            controlPath: sourcePath,
+            defaultSourceFolderPath: initialSourceFolderPath,
+            defaultPreparationPath: initialSourceFolderConfigPath,
+        };
     }
-    const seeded = seedLocalDefaultWorkflow({ sourcePath });
-    if (!seeded.alreadyExisted) {
-        p.log.info(`Copied built-in workflow package to interf/workflows/${seeded.workflowId}/ — inspect or fork it anytime.`);
+    else {
+        const seeded = seedLocalDefaultMethod({ sourcePath });
+        if (!seeded.alreadyExisted) {
+            p.log.info(`Method: ${seeded.methodId}`);
+        }
+    }
+    let currentConfig = loadSourceFolderConfig(sourcePath);
+    if (!currentConfig?.source_folder && !detected) {
+        const currentEntries = currentConfig?.preparations ?? [];
+        if (initialSourceFolderPath && initialSourceFolderConfigPath) {
+            saveSourceFolderConfig(sourcePath, {
+                source_folder: { path: initialSourceFolderConfigPath },
+                preparations: currentEntries,
+            });
+            currentConfig = loadSourceFolderConfig(sourcePath);
+        }
+        else if (currentConfig && currentEntries.length === 0) {
+            const sourceFolderPath = await promptSourceFolderForInstance(cwd);
+            if (!sourceFolderPath)
+                return;
+            const sourceFolderConfigPath = relativeSourceFolderPath(sourcePath, sourceFolderPath);
+            saveSourceFolderConfig(sourcePath, {
+                source_folder: { path: sourceFolderConfigPath },
+                preparations: [],
+            });
+            initialSourceFolderPath = sourceFolderPath;
+            initialSourceFolderConfigPath = sourceFolderConfigPath;
+            currentConfig = loadSourceFolderConfig(sourcePath);
+            p.log.info(`Source Folder: ${sourceFolderPath}`);
+            p.log.info(`Source Folder path in Interf config: ${sourceFolderConfigPath}`);
+        }
+        else if (!currentConfig) {
+            const setup = await setupInterfInstance(cwd);
+            if (!setup)
+                return;
+            sourcePath = setup.controlPath;
+            initialSourceFolderPath = setup.sourceFolderPath;
+            initialSourceFolderConfigPath = setup.sourceFolderConfigPath;
+            currentConfig = loadSourceFolderConfig(sourcePath);
+        }
     }
-    const savedEntries = listSavedCompiledEntries(sourcePath);
+    const configuredSourcePath = resolveConfiguredSourceFolderPath(sourcePath, currentConfig);
+    const configuredSourceConfigPath = configuredSourceFolderPath(currentConfig);
+    if (configuredSourcePath && configuredSourceConfigPath) {
+        initialSourceFolderPath = configuredSourcePath;
+        initialSourceFolderConfigPath = configuredSourceConfigPath;
+    }
+    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();
+        if (!action || action === "done") {
+            p.outro("Interf Workspace is ready. Next: run `interf web` or `interf create preparation`.");
+            return;
+        }
+        if (action === "web") {
+            await runWebCommand({ "control-path": sourcePath });
+            return;
+        }
+        if (action === "method") {
+            const methodId = await createMethodWizard({ sourcePath });
+            if (typeof methodId === "string") {
+                p.outro(`Saved Method "${methodId}". Next: create a Preparation and assign this Method.`);
+            }
+            return;
+        }
         const compiledConfig = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_COMPILED_NAME },
+            initial: initialSourceFolderPath && initialSourceFolderConfigPath
+                ? {
+                    name: defaultPreparationNameForPath(initialSourceFolderPath),
+                    path: initialSourceFolderConfigPath,
+                }
+                : { name: DEFAULT_PREPARATION_NAME },
+            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "first",
         });
         if (!compiledConfig)
@@ -501,7 +766,13 @@ export async function runInitCommand() {
     if (selectedCompiled === "__new__") {
         const compiledConfig = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_COMPILED_NAME },
+            initial: initialSourceFolderPath && initialSourceFolderConfigPath
+                ? {
+                    name: defaultPreparationNameForPath(initialSourceFolderPath),
+                    path: initialSourceFolderConfigPath,
+                }
+                : { name: DEFAULT_PREPARATION_NAME },
+            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "additional",
         });
         if (!compiledConfig)