@interf/compiler 0.7.2 → 0.9.1

package/dist/cli/commands/init.js

@@ -1,15 +1,167 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { resolve } from "node:path";
-import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
-import { DEFAULT_COMPILED_NAME, describeCompileLoopSelection, promptSingleCompiledConfig, } from "./source-config-wizard.js";
-import { buildCompiledWorkflowOptions, chooseCompiledWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
+import { existsSync, statSync } from "node:fs";
+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 { 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 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 = listDatasetFolderChoices(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 = 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.`);
+    }
+    return {
+        sourceFolderPath,
+        controlPath,
+        sourceFolderConfigPath,
+    };
+}
+async function promptEmptyInstanceAction() {
+    const selected = await p.select({
+        message: "What do you want to do 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,43 +175,43 @@ export function currentRunTargetStatus(rows, target) {
         return "mixed";
     return "fail";
 }
-function describeSavedQuestions(dataset) {
+function describeSavedReadinessChecks(dataset) {
     const count = dataset.checks.length;
     if (count === 0)
-        return "No questions yet";
-    return `${count} question${count === 1 ? "" : "s"}`;
+        return "No readiness checks yet";
+    return `${count} readiness check${count === 1 ? "" : "s"}`;
 }
 function printDatasetSummary(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}`);
+    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(`Workflow: ${workflowLabel}`);
+    p.log.info(`Method: ${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.");
+    p.log.info(describeSavedReadinessChecks(options.dataset));
+    p.log.info(options.built ? "Portable Context is available." : "Portable Context has not been built yet.");
     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 for your agents ${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: ${options.sourcePath}`);
     }
 }
 async function promptDatasetAction(dataset, built, latestComparison) {
@@ -67,45 +219,55 @@ async function promptDatasetAction(dataset, built, latestComparison) {
     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)",
+        hint: built
+            ? "Refresh it from the current source files"
+            : dataset.checks.length > 0
+                ? latestRawPasses
+                    ? "Prepare files for a side-by-side comparison with the latest saved source-files run"
+                    : 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",
+    };
     if (dataset.checks.length > 0) {
-        options.push({
+        const testOption = {
             value: "test",
             label: built
-                ? "Compare source files and the portable context your agents would use (Recommended)"
+                ? "Run readiness checks on source files and Portable Context (Recommended)"
                 : hasSavedRawBaseline
                     ? "Rerun the source-files baseline"
-                    : "Measure the source-files baseline (Recommended)",
+                    : "Measure the source-files baseline",
             hint: built
-                ? "See whether the portable context helps your agents on the saved questions"
+                ? "See whether the Portable Context is ready for your agents on the saved checks"
                 : hasSavedRawBaseline
-                    ? "Refresh the saved source-files baseline on the current questions"
-                    : "See whether the source files are already good enough before compiling",
-        });
+                    ? "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);
+        }
+        else {
+            options.push(compileOption, testOption);
+        }
+    }
+    else {
+        options.push(compileOption);
     }
     options.push({
-        value: "compile",
-        label: built ? "Rebuild portable context for your agents" : "Build portable context for your agents",
-        hint: built
-            ? "Refresh it from the current source files"
-            : dataset.checks.length > 0
-                ? latestRawPasses
-                    ? "Optional: build portable context for your agents for a side-by-side comparison with the latest saved source-files run"
-                    : hasSavedRawBaseline
-                        ? "Some questions still fail on the source files. Build portable context for your agents and compare it on the same questions"
-                        : "Build portable context for your agents and compare it on the same questions"
-                : "Build it for your agents first, then measure it",
-    }, {
         value: "dataset",
-        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",
     }, {
         value: "edit",
-        label: "Edit questions and settings",
-        hint: "Update questions, focus, workflow, or compile mode",
+        label: "Edit readiness checks and settings",
+        hint: "Update readiness checks, focus, Method, or prepare mode",
     }, {
         value: "workflow",
-        label: "Create workflow",
-        hint: "Advanced: customize the compile method",
+        label: "Create Method",
+        hint: "Advanced: customize how Interf prepares files",
     }, {
         value: "done",
         label: "Done",
@@ -121,20 +283,20 @@ async function promptDatasetAction(dataset, built, latestComparison) {
 }
 function printDatasetRecommendation(dataset, built, latestComparison) {
     if (dataset.checks.length === 0) {
-        p.log.info("Recommended first step: save a few questions for this dataset.");
+        p.log.info("No readiness checks yet. You can prepare files first, then add checks when you know what evidence matters.");
         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}. Rerun the baseline if you want current numbers for a different agent set, or build portable context for your agents 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 for your agents if you want Interf to prepare context for this work 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: measure the source-files baseline before compiling.");
+        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 the portable context your agents would use.");
+    p.log.info("Recommended first step: compare the source-files baseline and Portable Context.");
 }
 async function promptPostBaselineAction(rows) {
     const status = currentRunTargetStatus(rows, "raw");
@@ -155,28 +317,28 @@ async function promptPostBaselineAction(rows) {
             {
                 value: "compile",
                 label: compileRecommended
-                    ? "Build portable context for your agents (Recommended)"
-                    : "Build portable context for your agents",
+                    ? "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 for your agents and compare it on the same questions"
-                        : "Build portable context for your agents and compare it on the same questions"
-                    : "Build portable context for your agents 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",
             },
         ],
     });
@@ -194,22 +356,22 @@ async function chooseCompiledForWizard(options) {
     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 ?? entry.config.workflow ?? "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",
             },
         ],
     });
@@ -220,31 +382,28 @@ async function chooseCompiledForWizard(options) {
     return findSavedCompiledConfig(options.sourcePath, String(selected));
 }
 async function promptCompiledSetup(options) {
-    let workflowId = options.initial?.workflow ?? "interf-default";
-    let workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
-        .find((option) => option.value === workflowId)?.label ?? workflowId;
-    if (options.introStyle === "edit") {
-        const workflowChoice = await chooseCompiledWorkflow(options.sourcePath, {
-            currentWorkflowId: workflowId,
-            message: "Which workflow should this dataset use?",
-        });
-        if (p.isCancel(workflowChoice))
-            return null;
-        workflowId = workflowChoice;
-        workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
-            .find((option) => option.value === workflowId)?.label ?? workflowId;
-    }
+    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,
-        selectedWorkflowLabel: workflowLabel,
     });
     if (!compiledConfig)
         return null;
+    const workflowChoice = await chooseOrCreateCompiledWorkflowForDataset(options.sourcePath, compiledConfig, {
+        currentWorkflowId: options.initial?.workflow ?? "interf-default",
+        executionProfile: options.executionProfile,
+    });
+    if (!workflowChoice || p.isCancel(workflowChoice))
+        return null;
+    const workflowId = String(workflowChoice);
     const compiledConfigWithWorkflow = {
         ...compiledConfig,
+        method: workflowId,
         workflow: workflowId,
     };
     upsertSourceDatasetConfig(options.sourcePath, compiledConfigWithWorkflow, {
@@ -254,13 +413,16 @@ async function promptCompiledSetup(options) {
     if (builtCompiledPath) {
         syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, compiledConfigWithWorkflow);
     }
+    else {
+        ensurePortableContextScaffold(options.sourcePath, compiledConfigWithWorkflow.name, compiledConfigWithWorkflow.workflow ?? "interf-default");
+    }
     console.log();
-    console.log(chalk.green(`  ✓ Saved setup in ${SOURCE_FOLDER_CONFIG_FILE}`));
-    console.log(chalk.dim(`  Project folder: ${options.sourcePath}`));
-    console.log(chalk.dim(`  Setup: ${compiledConfigWithWorkflow.name}`));
+    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(`  Workflow: ${workflowLabel} · interf/workflows/${workflowId}/`));
-    console.log(chalk.dim(`  Compile mode: ${describeCompileLoopSelection({
+    console.log(chalk.dim(`  Method: ${workflowId} · interf/methods/${workflowId}/`));
+    console.log(chalk.dim(`  Prepare mode: ${describeCompileLoopSelection({
         maxAttempts: compiledConfigWithWorkflow.max_attempts,
         maxLoops: compiledConfigWithWorkflow.max_loops,
     })}`));
@@ -295,7 +457,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     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") {
@@ -309,6 +471,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         if (typeof workflowId === "string") {
             const nextConfig = {
                 ...compiledConfig,
+                method: workflowId,
                 workflow: workflowId,
             };
             upsertSourceDatasetConfig(sourcePath, nextConfig, {
@@ -318,7 +481,10 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             if (builtCompiledPath) {
                 syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
             }
-            p.log.info(`Assigned workflow "${workflowId}" to dataset "${compiledConfig.name}".`);
+            else {
+                ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.workflow ?? "interf-default");
+            }
+            p.log.info(`Assigned Method "${workflowId}" to Preparation "${compiledConfig.name}".`);
             p.log.info("Next: run `interf compile`, then `interf test`.");
         }
         return;
@@ -349,8 +515,8 @@ 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;
         }
@@ -408,7 +574,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             return;
         }
         if (compileResult.testedDuringCompile) {
-            p.log.info("This compile run already checked the portable context for your agents 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;
         }
@@ -427,14 +593,14 @@ 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 for your agents 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 the portable context your agents would use on the saved questions now?"
-                    : "Compare source files and the portable context your agents would use 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)
@@ -450,30 +616,119 @@ 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 portable context for your agents.");
-    p.log.info("Pick a source folder, review the suggested questions, and build when the files need more structure.");
+    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);
-    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(`Working from Interf Workspace: ${sourcePath}`);
     }
-    const seeded = seedLocalDefaultWorkflow({ sourcePath });
-    if (!seeded.alreadyExisted) {
-        p.log.info(`Copied built-in compilation workflow to interf/workflows/${seeded.workflowId}/ — inspect or fork it anytime.`);
+    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,
+        };
+    }
+    else {
+        const seeded = seedLocalDefaultWorkflow({ sourcePath });
+        if (!seeded.alreadyExisted) {
+            p.log.info(`Copied built-in Method package to interf/methods/${seeded.workflowId}/. Inspect or fork it anytime.`);
+        }
+    }
+    let currentConfig = loadSourceFolderConfig(sourcePath);
+    if (!currentConfig?.source_folder && !detected) {
+        const currentEntries = currentConfig?.preparations ?? currentConfig?.datasets ?? [];
+        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 configuredSourcePath = resolveConfiguredSourceFolderPath(sourcePath, currentConfig);
+    const configuredSourceConfigPath = configuredSourceFolderPath(currentConfig);
+    if (configuredSourcePath && configuredSourceConfigPath) {
+        initialSourceFolderPath = configuredSourcePath;
+        initialSourceFolderConfigPath = configuredSourceConfigPath;
     }
     const savedEntries = listSavedCompiledEntries(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 workflowId = await createWorkflowWizard({ sourcePath });
+            if (typeof workflowId === "string") {
+                p.outro(`Saved Method "${workflowId}". Next: create a Preparation and assign this Method.`);
+            }
+            return;
+        }
         const compiledConfig = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_COMPILED_NAME },
+            initial: initialSourceFolderPath && initialSourceFolderConfigPath
+                ? {
+                    name: defaultDatasetNameForPath(initialSourceFolderPath),
+                    path: initialSourceFolderConfigPath,
+                }
+                : { name: DEFAULT_COMPILED_NAME },
+            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "first",
         });
         if (!compiledConfig)
@@ -490,7 +745,13 @@ export async function runInitCommand() {
     if (selectedCompiled === "__new__") {
         const compiledConfig = await promptCompiledSetup({
             sourcePath,
-            initial: { name: DEFAULT_COMPILED_NAME },
+            initial: initialSourceFolderPath && initialSourceFolderConfigPath
+                ? {
+                    name: defaultDatasetNameForPath(initialSourceFolderPath),
+                    path: initialSourceFolderConfigPath,
+                }
+                : { name: DEFAULT_COMPILED_NAME },
+            ...(initialSourceFolderConfigPath ? { fixedPath: initialSourceFolderConfigPath } : {}),
             introStyle: "additional",
         });
         if (!compiledConfig)