@interf/compiler 0.7.3 → 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, 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 { 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 ${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) {
@@ -69,30 +221,30 @@ async function promptDatasetAction(dataset, built, latestComparison) {
         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 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
-                    ? "Build portable context agents can use for a side-by-side comparison with the latest saved source-files run"
+                    ? "Prepare files 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 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",
+                        ? "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) {
         const testOption = {
             value: "test",
             label: built
-                ? "Compare source files and portable context (Recommended)"
+                ? "Run readiness checks on source files and Portable Context (Recommended)"
                 : 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"
+                ? "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"
-                    : "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);
@@ -106,16 +258,16 @@ async function promptDatasetAction(dataset, built, latestComparison) {
     }
     options.push({
         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",
@@ -131,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}. 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");
@@ -165,28 +317,28 @@ async function promptPostBaselineAction(rows) {
             {
                 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",
             },
         ],
     });
@@ -204,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",
             },
         ],
     });
@@ -230,10 +382,14 @@ 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)
@@ -247,6 +403,7 @@ async function promptCompiledSetup(options) {
     const workflowId = String(workflowChoice);
     const compiledConfigWithWorkflow = {
         ...compiledConfig,
+        method: workflowId,
         workflow: workflowId,
     };
     upsertSourceDatasetConfig(options.sourcePath, compiledConfigWithWorkflow, {
@@ -260,12 +417,12 @@ async function promptCompiledSetup(options) {
         ensurePortableContextScaffold(options.sourcePath, compiledConfigWithWorkflow.name, compiledConfigWithWorkflow.workflow ?? "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.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: ${workflowId} · 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,
     })}`));
@@ -300,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") {
@@ -314,6 +471,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         if (typeof workflowId === "string") {
             const nextConfig = {
                 ...compiledConfig,
+                method: workflowId,
                 workflow: workflowId,
             };
             upsertSourceDatasetConfig(sourcePath, nextConfig, {
@@ -326,7 +484,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
             else {
                 ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.workflow ?? "interf-default");
             }
-            p.log.info(`Assigned workflow "${workflowId}" to dataset "${compiledConfig.name}".`);
+            p.log.info(`Assigned Method "${workflowId}" to Preparation "${compiledConfig.name}".`);
             p.log.info("Next: run `interf compile`, then `interf test`.");
         }
         return;
@@ -357,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;
         }
@@ -416,7 +574,7 @@ 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;
         }
@@ -435,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 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)
@@ -458,7 +616,7 @@ 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();
     },
@@ -466,25 +624,111 @@ export const initCommand = {
 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.");
+    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}`);
     }
-    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 = 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)
@@ -501,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)