@interf/compiler 0.6.1 → 0.6.4

package/dist/{commands → cli/commands}/compile-controller.js

@@ -2,14 +2,14 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
-import { readInterfConfig } from "../lib/interf.js";
-import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../lib/compiled-reset.js";
-import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
-import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
-import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
-import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
-import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
-import { initializeCompiledRuntimeState } from "../lib/state.js";
+import { readInterfConfig } from "../../packages/project-model/interf.js";
+import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../../packages/compiler/reset.js";
+import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../../packages/workflow-package/workflow-definitions.js";
+import { loadCompiledDatasetConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { runWorkflowImprovementLoop } from "../../packages/workflow-authoring/workflow-improvement.js";
+import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../../packages/compiler/compiled-paths.js";
+import { readCompiledSchemaFile } from "../../packages/compiler/compiled-schema.js";
+import { initializeCompiledRuntimeState } from "../../packages/compiler/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
 import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
@@ -78,16 +78,16 @@ async function runWorkflowVariation(options) {
                 const resetTarget = attempt > 1
                     ? `attempt ${attempt}/${options.maxAttempts}`
                     : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated compiled state before ${resetTarget}...`));
+                console.log(chalk.dim(`  Resetting generated portable-context state before ${resetTarget}...`));
                 resetCompiledGeneratedState(options.compiledPath, "compile");
             }
             const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building compiled dataset (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building compiled dataset (${options.variationLabel})...`,
+                    ? `Building portable context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building portable context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Compiled dataset ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Compiled dataset ready for ${options.variationLabel}.`,
+                    ? `Portable context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Portable context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
             });
             if (!result.ok) {
@@ -123,7 +123,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved compiled-dataset test after compile.",
+                    fatalError: "Could not run the saved portable-context comparison after compile.",
                 };
             }
             console.log();
@@ -138,7 +138,7 @@ async function runWorkflowVariation(options) {
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Compiled passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                console.log(chalk.green(`  Compiled context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
                 printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
@@ -181,11 +181,11 @@ function summarizeWorkflowVariation(options) {
     const passedQuestions = options.result.bestOutcome?.result.passedCases ?? 0;
     const totalQuestions = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalQuestions;
     const summary = options.result.passed
-        ? `Passed ${passedQuestions}/${totalQuestions} truth checks.`
+        ? `Passed ${passedQuestions}/${totalQuestions} questions.`
         : options.result.bestOutcome
-            ? `Best result: ${passedQuestions}/${totalQuestions} truth checks passed.`
+            ? `Best result: ${passedQuestions}/${totalQuestions} questions passed.`
             : options.result.failedStage
-                ? `Compile failed at stage ${options.result.failedStage} before any test result.`
+                ? `Compile failed at stage ${options.result.failedStage} before any saved comparison result.`
                 : "Workflow variation did not produce a passing result.";
     return {
         variation: options.variation,
@@ -213,16 +213,16 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
     }
 }
 function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Compiled dataset: ${options.compiledPath}`));
+    console.log(chalk.dim(`  Portable context: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add truth checks, then `interf test`."));
+        console.log(chalk.dim("  Next: run `interf` to add questions, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the compiled dataset or rerun `interf test` for a fresh comparison."));
+        console.log(chalk.dim("  Next: inspect the portable context, or run `interf test` if you also want a source-files-versus-portable-context comparison."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to compare the raw files and the compiled dataset."));
+    console.log(chalk.dim("  Next: run `interf test` to compare the source files and the portable context."));
 }
 function formatVariationQuestionSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -233,7 +233,7 @@ function printWorkflowVariationSummary(summaries) {
     console.log();
     console.log(chalk.bold("  Workflow variation summary"));
     console.log();
-    console.log("  | Variation | Kind | Truth checks | Result |");
+    console.log("  | Variation | Kind | Questions | Result |");
     console.log("  | --- | --- | --- | --- |");
     for (const summary of summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
@@ -245,7 +245,7 @@ function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
     console.log();
     console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForCompiled(compiledPath)}`));
     console.log(chalk.dim("  The project-level workflow selection was not changed automatically."));
-    console.log(chalk.dim("  Recompiling this existing compiled dataset reuses that local workflow draft."));
+    console.log(chalk.dim("  Recompiling this existing portable context reuses that local workflow draft."));
 }
 export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
@@ -255,12 +255,12 @@ export async function runConfiguredCompiledCompile(options) {
     const loopEnabled = maxAttempts != null;
     const checks = options.compiledConfig?.checks ?? [];
     if (loopEnabled && checks.length === 0) {
-        console.log(chalk.yellow("  Retry and self-improving modes need saved truth checks. Building once without those loops."));
+        console.log(chalk.yellow("  Retry and self-improving modes need saved questions. Building once without those loops."));
     }
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same workflow variation, check the portable context, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
@@ -295,11 +295,13 @@ export async function runConfiguredCompiledCompile(options) {
     const previousVariations = [];
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
-        const compiledConfig = options.compiledConfig ?? {
-            name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-            path: ".",
-            checks: [],
-        };
+        const compiledConfig = options.compiledConfig
+            ?? loadCompiledDatasetConfig(options.compiledPath)
+            ?? {
+                name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
+                path: "./dataset",
+                checks: [],
+            };
         const adoptVariationBest = (variation, result) => {
             if (result.bestOutcome && result.bestSnapshotPath && (!bestOutcome || testScore(result.bestOutcome) > testScore(bestOutcome))) {
                 if (bestSnapshotPath) {
@@ -412,20 +414,20 @@ export async function runConfiguredCompiledCompile(options) {
         if (bestSnapshotPath && bestVariation > 0) {
             restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing compiled dataset from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing portable context from variation ${bestVariation}, attempt ${bestAttempt}.`));
         }
         process.exitCode = 1;
         console.log();
         printWorkflowVariationSummary(previousVariations);
         printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
         if (maxLoops != null) {
-            console.log(chalk.red(`  Compiled did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Context folder did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }
         else {
-            console.log(chalk.red(`  Compiled did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Context folder did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt truth-check pass rate: ${questionPassRate(bestOutcome)}%.`));
+            console.log(chalk.dim(`  Best attempt test pass rate: ${questionPassRate(bestOutcome)}%.`));
         }
         printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;

package/dist/{commands → cli/commands}/compile.d.ts

@@ -1,6 +1,6 @@
 import * as p from "@clack/prompts";
-import { detectInterf } from "../lib/interf.js";
-import type { SourceDatasetConfig } from "../lib/schema.js";
+import { detectInterf } from "../../packages/project-model/interf.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
 import type { CommandModule } from "yargs";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig } from "./compiled-flow.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";

package/dist/{commands → cli/commands}/compile.js

@@ -1,8 +1,8 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
-import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
+import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { loadCompiledDatasetConfig, sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig, } from "./compiled-flow.js";
 import { resolveConfiguredDatasetSelection } from "./dataset-selection.js";
 import { promptCompileLoopSelection, } from "./source-config-wizard.js";
@@ -11,10 +11,10 @@ import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build a compiled dataset and optionally run retry or self-improving compile loops",
+    describe: "Build portable context and optionally run retry or self-improving compile loops",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
         type: "number",
-        describe: "Retry compile + test for the same workflow until the dataset passes or reaches this total attempt limit",
+        describe: "Retry compile and test the same workflow until the dataset passes or reaches this total attempt limit",
     }).option("max-loops", {
         type: "number",
         describe: "After retries fail, let Interf edit the workflow and test new workflow variations for this dataset up to this loop limit",
@@ -78,7 +78,8 @@ export async function runCompileCommand(argv = {}, deps = {}) {
     if (detected) {
         compiledPath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
-        compiledConfig = sourceDatasetConfigFromInterfConfig(detected.config);
+        compiledConfig = loadCompiledDatasetConfig(detected.path)
+            ?? sourceDatasetConfigFromInterfConfig(detected.config);
         if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await helpers.confirm({
                 message: `Compile dataset "${detected.config.name}" now?`,
@@ -97,18 +98,18 @@ export async function runCompileCommand(argv = {}, deps = {}) {
             })
             : await helpers.chooseCompiledConfigToBuild({
                 sourcePath,
-                selectMessage: "Which dataset do you want to compile?",
+                selectMessage: "Which source folder setup do you want to compile?",
             });
         if (selectedCompiled === undefined)
             return null;
         if (!selectedCompiled) {
             process.exitCode = 1;
             if (requestedDatasetName) {
-                console.log(chalk.red(`  Dataset "${requestedDatasetName}" is not set up in this project.`));
-                console.log(chalk.dim("  Run `interf list` to see the saved datasets."));
+                console.log(chalk.red(`  Setup "${requestedDatasetName}" is not set up in this project.`));
+                console.log(chalk.dim("  Run `interf list` to see the saved setups."));
             }
             else {
-                console.log(chalk.red("  No datasets are set up for this folder yet."));
+                console.log(chalk.red("  No saved setups are configured for this folder yet."));
                 console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
             }
             return null;
@@ -211,7 +212,10 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         };
     }
     const savedCompiledConfig = options.compiledConfig
-        ?? (currentConfig ? sourceDatasetConfigFromInterfConfig(currentConfig) : null);
+        ?? (currentConfig
+            ? (loadCompiledDatasetConfig(options.compiledPath)
+                ?? sourceDatasetConfigFromInterfConfig(currentConfig))
+            : null);
     if (!savedCompiledConfig) {
         return {
             compiledConfig: options.compiledConfig,

package/dist/{commands → cli/commands}/compiled-flow.d.ts

@@ -1,7 +1,6 @@
-import type { SourceDatasetConfig } from "../lib/schema.js";
-import { type StageShellRetentionMode } from "../lib/workflows.js";
-import type { WorkflowExecutor } from "../lib/executors.js";
-import type { CompiledCompileResult } from "../lib/workflows.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import { type StageShellRetentionMode, type CompiledCompileResult } from "../../packages/compiler/workflows.js";
+import type { WorkflowExecutor } from "../../packages/agents/lib/executors.js";
 export interface SavedDatasetEntry {
     config: SourceDatasetConfig;
     path: string | null;

package/dist/{commands → cli/commands}/compiled-flow.js

@@ -1,18 +1,18 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { listCompiledDatasetsForSourceFolder } from "../lib/interf.js";
-import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../lib/source-config.js";
-import { compileCompiled, createCompiled, } from "../lib/workflows.js";
-import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
+import { listCompiledDatasetsForSourceFolder } from "../../packages/project-model/interf.js";
+import { listSourceDatasetConfigs, loadCompiledDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, sourceDatasetConfigFromInterfConfig, syncCompiledInterfConfigFromSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { compileCompiled, createCompiled, } from "../../packages/compiler/workflows.js";
+import { formatWorkflowExecutionProfile } from "../../packages/agents/lib/execution-profile.js";
 function formatSavedDatasetHint(entry) {
     const config = entry.config;
     const checkCount = config.checks.length;
     const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
     if (config.about)
-        return `${config.about} · ${workflowHint}`;
+        return `${config.path} · ${config.about} · ${workflowHint}`;
     if (checkCount === 0)
-        return "No saved truth checks yet";
-    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+        return `${config.path} · No questions yet · ${workflowHint}`;
+    return `${config.path} · ${checkCount} question${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
 }
 export function listSavedCompiledEntries(sourcePath) {
     const builtEntries = new Map();
@@ -34,11 +34,6 @@ export function listSavedCompiledEntries(sourcePath) {
             localDraft: built?.localDraft ?? false,
         });
     }
-    for (const [name, built] of builtEntries.entries()) {
-        if (entries.has(name))
-            continue;
-        entries.set(name, built);
-    }
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
 export function findBuiltCompiledPath(sourcePath, compiledName) {
@@ -87,7 +82,7 @@ export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
 }
 export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
     console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building compiled dataset..."}`));
+    console.log(chalk.bold(`  ${options.heading ?? "Building portable context..."}`));
     const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
@@ -107,6 +102,6 @@ export async function compileCompiledWithReporter(executor, compiledPath, option
         return result;
     }
     console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled dataset ready."}`));
+    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Portable context ready."}`));
     return result;
 }

package/dist/{commands → cli/commands}/create-workflow-wizard.d.ts

@@ -1,7 +1,7 @@
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
-import type { SourceDatasetConfig } from "../lib/schema.js";
-import type { WorkflowExecutionProfile } from "../lib/executors.js";
+import { runWorkflowAuthoringDraft } from "../../packages/workflow-authoring/workflow-authoring.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { WorkflowExecutionProfile } from "../../packages/agents/lib/executors.js";
 export interface WorkflowWizardPrompts {
     intro(message: string): void;
     select(options: {

package/dist/{commands → cli/commands}/create-workflow-wizard.js

@@ -1,14 +1,14 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { statSync } from "node:fs";
 import { resolve } from "node:path";
-import { listCompiledWorkflowChoices, getCompiledWorkflow, } from "../lib/workflow-definitions.js";
-import { createLocalWorkflowPackageFromTemplate } from "../lib/interf-workflow-package.js";
-import { isWorkflowId, } from "../lib/local-workflows.js";
+import { listCompiledWorkflowChoices, getCompiledWorkflow, } from "../../packages/workflow-package/workflow-definitions.js";
+import { createLocalWorkflowPackageFromTemplate } from "../../packages/workflow-package/interf-workflow-package.js";
+import { isWorkflowId, } from "../../packages/workflow-package/local-workflows.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
-import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../lib/source-config.js";
-import { slugify } from "../lib/util.js";
+import { runWorkflowAuthoringDraft } from "../../packages/workflow-authoring/workflow-authoring.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../../packages/project-model/source-config.js";
+import { slugify } from "../../packages/shared/naming.js";
+import { DEFAULT_DATASET_PATH_PLACEHOLDER, listDatasetFolderChoices, normalizeDatasetPathForConfig, } from "./source-config-wizard.js";
 export const clackWorkflowPrompts = {
     intro: p.intro,
     select: (options) => p.select(options),
@@ -30,7 +30,49 @@ function findMatchingDatasetConfig(sourcePath, datasetPath) {
 }
 function describeSavedDataset(dataset) {
     return dataset.about
-        ?? `${dataset.checks.length} saved truth check${dataset.checks.length === 1 ? "" : "s"} · path ${dataset.path}`;
+        ? `${dataset.path} · ${dataset.about}`
+        : `${dataset.path} · ${dataset.checks.length} test${dataset.checks.length === 1 ? "" : "s"}`;
+}
+async function promptWorkflowDatasetFolder(sourcePath, prompts) {
+    const folderChoices = listDatasetFolderChoices(sourcePath);
+    if (folderChoices.length > 0) {
+        const selected = await prompts.select({
+            message: "Which source folder should shape this workflow?",
+            options: [
+                ...folderChoices,
+                {
+                    value: "__manual__",
+                    label: "Enter a different path",
+                    hint: "Use a relative path if the source folder is not listed here",
+                },
+            ],
+        });
+        if (prompts.isCancel(selected))
+            return selected;
+        if (selected !== "__manual__") {
+            return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(selected)));
+        }
+    }
+    const datasetFolder = await prompts.text({
+        message: "Which source folder should shape this workflow?",
+        placeholder: DEFAULT_DATASET_PATH_PLACEHOLDER,
+        initialValue: folderChoices.length === 1 ? folderChoices[0]?.value : undefined,
+        validate: (value) => {
+            const trimmed = value.trim();
+            if (trimmed.length === 0)
+                return "Source folder is required";
+            try {
+                normalizeDatasetPathForConfig(sourcePath, trimmed);
+                return undefined;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : String(error);
+            }
+        },
+    });
+    if (prompts.isCancel(datasetFolder))
+        return datasetFolder;
+    return resolve(sourcePath, normalizeDatasetPathForConfig(sourcePath, String(datasetFolder)));
 }
 export function formatWorkflowLabel(workflow) {
     return {
@@ -93,8 +135,8 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         options: [
             {
                 value: "draft",
-                label: "Draft a workflow from this dataset (Recommended)",
-                hint: "Seed a workflow, prepare a preview, then let a local agent draft a reusable method for this task",
+                label: "Draft a workflow from this source folder (Recommended)",
+                hint: "Seed a workflow, build a preview, then let a local agent draft a reusable method for this kind of work",
             },
             {
                 value: "manual",
@@ -138,7 +180,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
             if (savedDatasets.length > 0) {
                 const datasetChoice = await prompts.select({
-                    message: "Which dataset should shape this workflow?",
+                    message: "Which source folder setup should shape this workflow?",
                     options: [
                         ...savedDatasets.map((dataset) => ({
                             value: dataset.name,
@@ -163,41 +205,26 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             }
         }
         if (!datasetPath) {
-            const datasetFolder = await prompts.text({
-                message: "Which dataset folder should shape this workflow?",
-                placeholder: ".",
-                initialValue: ".",
-                validate: (value) => {
-                    const trimmed = value.trim();
-                    if (trimmed.length === 0)
-                        return "Dataset folder is required";
-                    const absolutePath = resolve(sourcePath, trimmed);
-                    try {
-                        const stat = statSync(absolutePath);
-                        return stat.isDirectory() ? undefined : "Dataset folder must be a directory";
-                    }
-                    catch {
-                        return "Dataset folder was not found";
-                    }
-                },
-            });
+            const datasetFolder = await promptWorkflowDatasetFolder(sourcePath, prompts);
             if (prompts.isCancel(datasetFolder))
                 return datasetFolder;
-            datasetPath = resolve(sourcePath, String(datasetFolder).trim());
+            if (!datasetFolder)
+                return null;
+            datasetPath = String(datasetFolder);
             matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
         }
         const taskPrompt = await prompts.text({
-            message: "What task should this workflow prepare the dataset for?",
-            placeholder: "Example: chart reads, board-prep questions, or latest planned launch status",
-            validate: (value) => (value.trim().length === 0 ? "Task focus is required" : undefined),
+            message: "What kind of work should this workflow help with?",
+            placeholder: "Example: chart reads, board prep, or latest planned launch status",
+            validate: (value) => (value.trim().length === 0 ? "Work focus is required" : undefined),
         });
         if (prompts.isCancel(taskPrompt))
             return taskPrompt;
         if (matchedDataset) {
-            prompts.log.info(`Shaping this workflow from dataset "${matchedDataset.name}".`);
+            prompts.log.info(`Shaping this workflow from setup "${matchedDataset.name}".`);
         }
         if (matchedDataset?.checks.length) {
-            prompts.log.info(`Using ${matchedDataset.checks.length} saved truth check${matchedDataset.checks.length === 1 ? "" : "s"} from dataset "${matchedDataset.name}" as authoring context.`);
+            prompts.log.info(`Using ${matchedDataset.checks.length} saved question${matchedDataset.checks.length === 1 ? "" : "s"} from setup "${matchedDataset.name}" as authoring context.`);
         }
         const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
         const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
@@ -213,7 +240,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             (prompts.log.error ?? prompts.log.info)(error ?? "No coding agent detected.");
             return null;
         }
-        prompts.log.info("Preparing a workflow-authoring preview from the dataset, then drafting the package.");
+        prompts.log.info("Preparing a workflow-authoring preview from the source folder, then drafting the package.");
         const result = await runDraft({
             sourcePath,
             datasetPath,
@@ -232,7 +259,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         }
         process.exitCode = 1;
         (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
-            ? `${result.summary} Draft mode only succeeds when it produces a task-specific package change.`
+            ? `${result.summary} Draft mode only succeeds when it produces a work-specific package change.`
             : result.summary);
         prompts.log.info(`Workflow shell kept at: ${result.shellPath}`);
         return null;

package/dist/{commands → cli/commands}/create.d.ts

@@ -1,5 +1,5 @@
 import type { CommandModule } from "yargs";
-import type { WorkflowExecutionProfile } from "../lib/executors.js";
+import type { WorkflowExecutionProfile } from "../../packages/agents/lib/executors.js";
 export declare const createCommand: CommandModule;
 export declare function createCompiledWizard(options?: {
     intro?: boolean;

package/dist/{commands → cli/commands}/create.js

@@ -1,10 +1,8 @@
 import chalk from "chalk";
-import { basename } from "node:path";
 import * as p from "@clack/prompts";
-import { detectInterf, defaultCompiledNameForSource, listCompiledDatasetsForSourceFolder, resolveSourceControlPath, } from "../lib/interf.js";
-import { slugify } from "../lib/util.js";
-import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
+import { listSourceDatasetConfigs, loadSourceFolderConfig, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../../packages/project-model/source-config.js";
 import { createWorkflowWizard, } from "./create-workflow-wizard.js";
 import { findBuiltCompiledPath, } from "./compiled-flow.js";
 import { DEFAULT_COMPILED_NAME, promptSingleCompiledConfig, } from "./source-config-wizard.js";
@@ -44,7 +42,7 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
     const datasets = listSourceDatasetConfigs(config);
     if (datasets.length === 0) {
         p.log.info(`Created workflow "${workflowId}".`);
-        p.log.info(`Next: run \`interf\`, add a dataset, then assign workflow "${workflowId}" from that dataset menu.`);
+        p.log.info(`Next: run \`interf\`, add a setup, then assign workflow "${workflowId}" from that menu.`);
         return;
     }
     const assignNow = await p.confirm({
@@ -53,17 +51,17 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
     });
     if (p.isCancel(assignNow) || !assignNow) {
         p.log.info(`Created workflow "${workflowId}".`);
-        p.log.info(`Next: run \`interf\`, open a dataset, and assign workflow "${workflowId}" from that dataset menu.`);
+        p.log.info(`Next: run \`interf\`, open a saved setup, and assign workflow "${workflowId}" from that menu.`);
         return;
     }
     let targetDataset = datasets[0] ?? null;
     if (datasets.length > 1) {
         const selected = await p.select({
-            message: "Which dataset should use this workflow?",
+            message: "Which source folder setup should use this workflow?",
             options: datasets.map((dataset) => ({
                 value: dataset.name,
                 label: dataset.name,
-                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} saved truth check${dataset.checks.length === 1 ? "" : "s"}`}`,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} question${dataset.checks.length === 1 ? "" : "s"}`}`,
             })),
         });
         if (p.isCancel(selected))
@@ -85,7 +83,7 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
     }
     p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
     if (builtCompiledPath) {
-        p.log.info("The active local copy for that built dataset lives under `.interf/workflow/`.");
+        p.log.info("The active local workflow copy for that portable context lives under `.interf/workflow/`.");
     }
     p.log.info("Next: run `interf compile`, then `interf test`.");
 }
@@ -134,19 +132,18 @@ export async function createCompiledWizard(options = {}) {
     const detected = detectInterf(cwd);
     if (detected) {
         process.exitCode = 1;
-        p.log.error("You are already inside a compiled dataset.");
+        p.log.error("You are already inside portable context.");
         return;
     }
-    const existing = listCompiledDatasetsForSourceFolder(cwd);
-    if (existing.length > 0) {
-        p.log.info(`This project already has ${existing.length} compiled dataset${existing.length === 1 ? "" : "s"}. Add another only when you need a separate folder, truth checks, or focus.`);
+    const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(cwd));
+    if (savedDatasets.length > 0) {
+        p.log.info(`This project already has ${savedDatasets.length} saved setup${savedDatasets.length === 1 ? "" : "s"} in interf.json. Add another only when you need a separate folder, focus, or question set.`);
     }
-    p.log.info("Interf works one dataset at a time. Start with the task, truth checks, and a baseline, then build a compiled dataset only when you need it.");
+    p.log.info("Interf works one source-folder setup at a time. Start with the work, the relevant files, and a few questions, then build portable context when you want to prepare context your agents can work from.");
     const existingConfig = loadSourceFolderConfig(cwd);
-    const suggestedName = slugify(defaultCompiledNameForSource(cwd) || basename(cwd)) || DEFAULT_COMPILED_NAME;
     const draft = await promptSingleCompiledConfig({
         projectPath: cwd,
-        initial: { name: suggestedName },
+        initial: { name: DEFAULT_COMPILED_NAME },
         introStyle: existingConfig ? "additional" : "first",
     });
     if (!draft)
@@ -158,7 +155,7 @@ export async function createCompiledWizard(options = {}) {
     const existingNames = new Set(listSourceDatasetConfigs(existingConfig).map((dataset) => dataset.name));
     if (existingNames.has(configToSave.name)) {
         process.exitCode = 1;
-        p.log.error(`Dataset "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
+        p.log.error(`Setup "${configToSave.name}" already exists. Use \`interf\` or \`interf init\` to edit it.`);
         return;
     }
     upsertSourceDatasetConfig(cwd, configToSave);

package/dist/{commands → cli/commands}/dataset-selection.d.ts

@@ -1,4 +1,4 @@
-import type { SourceDatasetConfig } from "../lib/schema.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
 export declare function resolveConfiguredDatasetSelection(options: {
     sourcePath: string;
     requestedDatasetName?: string | null;

package/dist/{commands → cli/commands}/default.js

@@ -1,11 +1,11 @@
 import chalk from "chalk";
-import { loadUserConfig } from "../lib/user-config.js";
+import { userConfig } from "../../packages/agents/index.js";
 import { runInitCommand } from "./init.js";
 function printStaticLanding() {
-    const config = loadUserConfig();
+    const config = userConfig.loadUserConfig();
     console.log();
     console.log(chalk.bold("  Interf"));
-    console.log(chalk.dim("  Define the task, save truth checks, measure raw files first, then compile only if they are not good enough."));
+    console.log(chalk.dim("  Prepare context for your agents from the files you already have, then run `interf test` and use self-improving loops until more questions pass."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));