@interf/compiler 0.9.1 → 0.9.4

package/README.md

@@ -83,7 +83,7 @@ Requires Node.js 20+ and a local coding agent such as Claude Code or Codex. Run
 7. Run `interf test` to check readiness.
 8. If agents pass more checks with portable context, point your agent at `interf/<preparation>/`.
 
-If you want a baseline before preparing, run `interf test --target raw`. It is optional proof, not the main path.
+If you want a baseline before preparing, run `interf test --target source-files`. It is optional proof, not the main path.
 
 `interf init` sets up the local Interf Workspace, saves `interf/interf.json`, and copies the built-in Method to `interf/methods/interf-default/`. It does not create a Preparation until you choose to add one. The Method is stored as a Method package you can inspect, edit, or fork with `interf create method`.
 
@@ -119,8 +119,8 @@ A Method tells Interf how to process your files for the job agents need to do. W
 
 ```text
 interf/methods/interf-default/
-  workflow.json         # Method: source data, stages, and processing rules
-  workflow.schema.json  # output contract: required portable-context files and folders
+  method.json         # Method: source data, stages, and processing rules
+  method.schema.json  # output contract: required portable-context files and folders
   README.md             # what this Method is for, for humans and agents
   compile/
     stages/
@@ -132,13 +132,13 @@ interf/methods/interf-default/
   improve/              # how Interf revises this Method if readiness checks still fail
 ```
 
-- `workflow.json` describes the Method: source data, stages, and how the files should be processed.
-- `workflow.schema.json` describes the output contract: what the portable context must contain. Interf enforces it when you run `interf compile`.
+- `method.json` describes the Method: source data, stages, and how the files should be processed.
+- `method.schema.json` describes the output contract: what the portable context must contain. Interf enforces it when you run `interf compile`.
 - `compile/stages/<stage>/` is where you author one folder per stage — a small, specific phase like `summarize` or `structure`. You write the instructions; Interf runs them during compile.
 - `use/query/` holds the instructions agents follow when they read the portable context for live agent work.
 - `improve/` holds the instructions Interf follows when the first build misses and the Method itself needs editing.
 
-A Method defines the stages, output contract, proof requirements, and improvement instructions Interf runs on your files. Technically, each Method is stored as a Method package with `workflow.json` and `workflow.schema.json`. The result is portable context your agents can read.
+A Method defines the stages, output contract, proof requirements, and improvement instructions Interf runs on your files. Technically, each Method is stored as a Method package with `method.json` and `method.schema.json`. The result is portable context your agents can read.
 
 ## Method Improvement
 
@@ -152,7 +152,7 @@ Interf saves every readiness-check run under `interf/<preparation>/.interf/tests
 
 Readiness is one `ready` / `not ready` status, not a separate score. Interf builds it from evidence primitives: stage/Method acceptance criteria, proof records, file coverage, artifact validation, and readiness checks.
 
-`interf web` starts the local Interf service and serves Interf UI. The UI reads local-service resources: Preparations, Methods, runs, stages, proof, artifacts, readiness checks, and whether portable context is `ready` or `not ready`. It renders local compiler state; it does not own compiler, Method, or readiness semantics.
+`interf web` starts the local Interf service and serves Interf Compiler UI. The UI reads local-service resources: Preparations, Methods, runs, stages, proof, artifacts, readiness checks, and whether portable context is `ready` or `not ready`. It renders local compiler state; it does not own compiler, Method, or readiness semantics.
 
 Maintainer package boundaries live in [src/packages/README.md](./src/packages/README.md).
 
@@ -206,7 +206,7 @@ A maintained readiness example in this repo uses one market report, two readines
 | Claude Code (Claude Opus 4.6, max) | `0/2` | `2/2` |
 <!-- PUBLIC_BENCHMARK_TABLE:END -->
 
-Codex passed from the raw files; Claude Code only passed when working from Interf's portable context. Both numbers come from the same readiness-check pass. That is evidence about whether this Preparation is `ready` for this agent work.
+Codex passed from the Source Folder files; Claude Code only passed when working from Interf's portable context. Both numbers come from the same readiness-check pass. That is evidence about whether this Preparation is `ready` for this agent work.
 
 A maintained public test example in this repo stores them like this:
 
@@ -244,7 +244,7 @@ A maintained public test example in this repo stores them like this:
 ## Useful Commands
 
 - `interf` or `interf init` — set up the Interf Workspace or manage Preparations
-- `interf web` — start Interf UI and the local API for this Workspace
+- `interf web` — start Interf Compiler UI and the local API for this Workspace
 - `interf compile` — build portable context agents can use
 - `interf test` — run readiness checks against source files and/or portable context
 - `interf create method` — draft a reusable Method

package/agent-skills/interf-actions/SKILL.md

@@ -27,6 +27,7 @@ In Interf Compiler UI proposal mode, do not run CLI commands. Use `references/cl
 - Do not invent readiness checks, Method ids, paths, or executor names.
 - If the local service is running, `interf compile` and `interf test` submit visible runs to Interf Compiler UI.
 - Propose the command first and wait for approval before running commands that write files, start runs, create Method packages, build portable context, or run readiness checks.
+- If the request names an existing Preparation and asks to prepare, build, or refresh portable context, use `interf compile --preparation <name>`. The saved Preparation and selected Method are the source of truth.
 - If the request is ambiguous, ask one concise clarification instead of guessing.
 
 ## Interf Compiler UI Proposal Mode
@@ -44,6 +45,8 @@ Use these action types:
 
 Use `preparation-setup` when no Preparation is saved yet or when the user asks to initialize/add a source folder. Set `values.path` to a visible source folder path such as `./Reports`, set `preparation` or `values.name` to the Preparation id, and set `values.about` to the agent work the source folder should support. CLI equivalent: `interf init` or `interf create preparation`.
 
+Use `compile` when the user asks to prepare, build, or refresh portable context for an existing Preparation. Do not ask what "prepare" means when the Preparation exists. Set `preparation` to the selected or mentioned Preparation id. CLI equivalent: `interf compile --preparation <name>`.
+
 For a readiness-check proposal, set `values.mode` to:
 
 - `raw` for source files only

package/agent-skills/interf-actions/references/cli.md

@@ -10,16 +10,16 @@ This snapshot is bundled with the `interf-actions` skill. The installed `interf`
 interf
 
 Commands:
-  interf init            Set up Interf or open the Preparation wizard
-  interf compile         Prepare files and write Portable Context agents can use
-  interf test            Run readiness checks against source files and Portable Context
-  interf create [type]   Create a Preparation or reusable Method
-  interf doctor          Check local executor configuration before a real local run
-  interf list            List saved Preparations in this Source Folder
-  interf status          Show deterministic health for the Portable Context agents use
-  interf verify <check>  Run deterministic verification checks
-  interf web             Start Interf UI and the local Interf API
-  interf reset <scope>   Reset generated Portable Context state while keeping source files and the local Method package
+  interf init                      Set up Interf or open the Preparation wizard
+  interf compile                   Prepare files and write Portable Context agents can use
+  interf test                      Run readiness checks against source files and Portable Context
+  interf create [type]             Create a Preparation or reusable Method
+  interf doctor                    Check local executor configuration before a real local run
+  interf list                      List saved Preparations in this Source Folder
+  interf status                    Show deterministic health for the Portable Context agents use
+  interf verify <check> [stageId]  Run deterministic verification checks
+  interf web                       Start Interf UI and the local Interf API
+  interf reset <scope>             Reset generated Portable Context state while keeping source files and the local Method package
 
 Options:
   --help     Show help                                                                                                                                 [boolean]
@@ -96,7 +96,7 @@ Options:
   --timeout-ms      Interrupt the local executor after this much inactivity                                                                             [number]
   --preparation     Preparation id to check when this Source Folder has more than one Preparation                                                       [string]
   --target          Check source files, Portable Context, or both. Default: both when Portable Context exists, otherwise source files.
-                                                                                                                            [choices: "both", "raw", "compiled"]
+                                                                                                           [choices: "both", "source-files", "portable-context"]
   --keep-sandboxes  Keep every readiness-check sandbox for review instead of pruning successful ones                                  [boolean] [default: false]
   --agents          Comma-separated local agents to use for readiness checks, or `all`. Example: --agents claude-code,codex                             [string]
 ```
@@ -159,12 +159,12 @@ Options:
 ## interf verify
 
 ```text
-interf verify <check>
+interf verify <check> [stageId]
 
 Run deterministic verification checks
 
 Positionals:
-  check    Check to run (`stage`, `compiled`, or `method`)                                                                                   [string] [required]
+  check    Check to run (`stage`, `portable-context`, or `method`)                                                                           [string] [required]
   stageId  Stage id when using `verify stage <stage-id>`                                                                                                [string]
 
 Options:

package/{builtin-workflows/interf → builtin-methods/interf-default}/README.md

@@ -26,6 +26,6 @@ Built-in file-processing Method: summarize source-grounded evidence, structure c
 ## Why `home.md` exists here
 
 This built-in Method creates `home.md` as the main agent entrypoint for the portable context.
-That is behavior of the `interf` Method, not a compiler-wide rule.
+That is behavior of the `interf-default` Method, not a compiler-wide rule.
 
-This package is the built-in seed for `interf`.
+This package is the built-in seed for `interf-default`.

package/builtin-methods/interf-default/improve/SKILL.md

@@ -0,0 +1,18 @@
+# Method Improvement
+
+Method: interf-default
+
+This file is the editable authoring source for Interf's generated native Method-improver shell.
+The improver edits this local package directly.
+
+Default loop:
+1. Read the loop context first.
+2. Review preserved stage shells, runtime logs, and saved test runs from failed attempts.
+3. Edit only the local Method package for this portable context to create a better Method variation for this task.
+4. Keep `method.json`, `method.schema.json`, and any changed stage docs aligned.
+
+Guardrails:
+- do not edit checks, test specs, or raw source files
+- do not hardcode expected answers into Method docs
+- keep this package standalone; do not rely on runtime inheritance
+- prefer small, defensible Method changes over random churn

package/{builtin-workflows/interf/workflow.json → builtin-methods/interf-default/method.json}

@@ -1,16 +1,16 @@
 {
-  "id": "interf",
+  "id": "interf-default",
   "type": "compiled",
   "compiler_api": {
     "kind": "compiled",
     "version": 1
   },
   "purpose": {
-    "label": "Built-in portable-context workflow for agent use",
+    "label": "Built-in portable-context Method for agent use",
     "task_hint": "Compile mixed raw files into evidence-backed summaries, cross-file structure, and a usable entrypoint for agents running the readiness checks this task depends on."
   },
-  "label": "Built-in Interf Workflow",
-  "hint": "Built-in file-processing workflow: summarize source-grounded evidence, structure cross-file connections, and shape portable context around the saved readiness checks.",
+  "label": "Built-in Interf Method",
+  "hint": "Built-in file-processing Method: summarize source-grounded evidence, structure cross-file connections, and shape portable context around the saved readiness checks.",
   "stages": [
     {
       "id": "summarize",

package/{builtin-workflows/interf/workflow.schema.json → builtin-methods/interf-default/method.schema.json}

@@ -1,8 +1,8 @@
 {
-  "kind": "workflow-schema",
+  "kind": "method-schema",
   "version": 1,
   "target_type": "compiled",
-  "label": "Interf built-in workflow schema",
+  "label": "Interf built-in Method schema",
   "zones": [
     {
       "id": "raw",

package/dist/cli/commands/check-draft.d.ts

@@ -1,17 +1,17 @@
-import type { WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { MethodExecutor } from "../../packages/agents/lib/executors.js";
 import type { SourceReadinessCheck } from "../../packages/project-model/lib/schema.js";
 export declare function buildReadinessCheckDraftPrompt(options: {
-    datasetName: string;
-    datasetPath: string;
+    preparationName: string;
+    sourceFolderPath: string;
     about?: string;
     outputPath: string;
     targetCount: number;
 }): string;
 export declare function draftReadinessChecks(options: {
-    datasetName: string;
-    datasetPath: string;
+    preparationName: string;
+    sourceFolderPath: string;
     about?: string;
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     targetCount?: number;
     onStatus?: (line: string) => void;
 }): Promise<{

package/dist/cli/commands/check-draft.js

@@ -25,8 +25,8 @@ export function buildReadinessCheckDraftPrompt(options) {
         "Do not ask follow-up questions.",
         "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the files in this Source Folder.",
         "",
-        `Preparation id: ${options.datasetName}`,
-        `Source Folder: ${options.datasetPath}`,
+        `Preparation id: ${options.preparationName}`,
+        `Source Folder: ${options.sourceFolderPath}`,
         ...taskLines,
         "",
         `Write exactly one JSON array to ${JSON.stringify(options.outputPath)}.`,
@@ -57,15 +57,15 @@ export async function draftReadinessChecks(options) {
     const outputPath = join(tempDir, "checks.json");
     const promptPath = join(tempDir, "prompt.txt");
     const prompt = buildReadinessCheckDraftPrompt({
-        datasetName: options.datasetName,
-        datasetPath: options.datasetPath,
+        preparationName: options.preparationName,
+        sourceFolderPath: options.sourceFolderPath,
         about: options.about,
         outputPath,
         targetCount: options.targetCount ?? 4,
     });
     writeFileSync(promptPath, `${prompt}\n`);
     try {
-        const code = await options.executor.execute(options.datasetPath, prompt, {
+        const code = await options.executor.execute(options.sourceFolderPath, prompt, {
             completionCheck: () => existsSync(outputPath),
             onStatus: options.onStatus,
         });

package/dist/cli/commands/compile-controller.d.ts

@@ -1,14 +1,14 @@
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../../packages/agents/lib/executors.js";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
-import type { StageShellRetentionMode } from "../../packages/compiler/workflows.js";
+import type { MethodExecutionProfile, MethodExecutor } from "../../packages/agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import type { StageShellRetentionMode } from "../../packages/compiler/method-runs.js";
 import type { RunEventSink } from "../../packages/execution/events.js";
 export declare function runConfiguredCompiledCompile(options: {
-    executor: WorkflowExecutor;
-    testExecutor?: WorkflowExecutor | null;
+    executor: MethodExecutor;
+    testExecutor?: MethodExecutor | null;
     compiledPath: string;
     sourcePath: string;
-    compiledConfig: SourceDatasetConfig | null;
-    executionProfile?: WorkflowExecutionProfile;
+    compiledConfig: SourcePreparationConfig | null;
+    executionProfile?: MethodExecutionProfile;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
     preserveStageShells?: StageShellRetentionMode;

package/dist/cli/commands/compile-controller.js

@@ -3,25 +3,31 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 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 { clearCompiledRuntimeDerivedArtifacts, } from "../../packages/compiler/reset.js";
+import { formatActiveCompiledMethodStageStep, resolveRequiredCompiledMethodFromConfig, } from "../../packages/method-package/method-definitions.js";
+import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { runMethodImprovementLoop } from "../../packages/method-authoring/method-improvement.js";
+import { stageExecutionShellsRoot, methodPackagePathForCompiled, } 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, readinessPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
-    resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
-    const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, failedStage ?? "compile");
+    resolveRequiredCompiledMethodFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
+    let failedStageLabel = failedStage ? `Stage "${failedStage}"` : "Compile";
+    try {
+        failedStageLabel = formatActiveCompiledMethodStageStep(compiledPath, failedStage ?? "compile");
+    }
+    catch {
+        // Keep the original failure visible even when the failure is outside a declared Method stage.
+    }
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
 function bestVariationRestorePaths(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
         .filter((zone) => zone.id !== "raw" && zone.kind !== "runtime")
         .map((zone) => zone.path);
@@ -65,7 +71,7 @@ function restoreCompiledBestState(snapshotPath, compiledPath) {
     clearCompiledRuntimeDerivedArtifacts(compiledPath);
     initializeCompiledRuntimeState(compiledPath);
 }
-async function runWorkflowVariation(options) {
+async function runMethodVariation(options) {
     let bestOutcome = null;
     let bestSnapshotPath = null;
     let bestAttempt = 0;
@@ -73,14 +79,6 @@ async function runWorkflowVariation(options) {
     try {
         for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
             attemptsRun = attempt;
-            if (attempt > 1 || (attempt === 1 && options.resetBeforeFirstAttempt)) {
-                console.log();
-                const resetTarget = attempt > 1
-                    ? `attempt ${attempt}/${options.maxAttempts}`
-                    : options.variationLabel;
-                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 Portable Context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
@@ -111,7 +109,7 @@ async function runWorkflowVariation(options) {
             }
             const outcome = await runSavedCompiledTest({
                 sourcePath: options.sourcePath,
-                datasetConfig: options.compiledConfig,
+                preparationConfig: options.compiledConfig,
                 executor: options.testExecutor,
                 executionProfile: options.executionProfile,
                 compiledPath: options.compiledPath,
@@ -179,7 +177,7 @@ async function runWorkflowVariation(options) {
         };
     }
 }
-function summarizeWorkflowVariation(options) {
+function summarizeMethodVariation(options) {
     const passedChecks = options.result.bestOutcome?.result.passedCases ?? 0;
     const totalChecks = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalChecks;
     const summary = options.result.passed
@@ -229,7 +227,7 @@ function printPostCompileNextStep(options) {
 function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
 }
-function printWorkflowVariationSummary(summaries) {
+function printMethodVariationSummary(summaries) {
     if (summaries.length === 0)
         return;
     console.log();
@@ -241,18 +239,18 @@ function printWorkflowVariationSummary(summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationReadinessSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
     }
 }
-function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
+function printCompiledLocalMethodOwnership(compiledPath, bestVariation) {
     if (bestVariation <= 1)
         return;
     console.log();
-    console.log(chalk.dim(`  Best Method variation now lives in: ${workflowPackagePathForCompiled(compiledPath)}`));
+    console.log(chalk.dim(`  Best Method variation now lives in: ${methodPackagePathForCompiled(compiledPath)}`));
     console.log(chalk.dim("  The project-level Method selection was not changed automatically."));
     console.log(chalk.dim("  Recompiling this existing Portable Context reuses that local Method draft."));
 }
 export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
-    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const configuredMaxAttempts = resolvePreparationCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolvePreparationCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
     const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
     const loopEnabled = maxAttempts != null;
     const checks = options.compiledConfig?.checks ?? [];
@@ -300,10 +298,10 @@ export async function runConfiguredCompiledCompile(options) {
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
         const compiledConfig = options.compiledConfig
-            ?? loadCompiledDatasetConfig(options.compiledPath)
+            ?? loadCompiledPreparationConfig(options.compiledPath)
             ?? {
                 name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-                path: "./dataset",
+                path: "./source-folder",
                 checks: [],
             };
         const adoptVariationBest = (variation, result) => {
@@ -322,7 +320,7 @@ export async function runConfiguredCompiledCompile(options) {
                 result.bestSnapshotPath = null;
             }
         };
-        const baseline = await runWorkflowVariation({
+        const baseline = await runMethodVariation({
             executor: options.executor,
             testExecutor: options.testExecutor,
             compiledPath: options.compiledPath,
@@ -341,14 +339,14 @@ export async function runConfiguredCompiledCompile(options) {
             return false;
         }
         adoptVariationBest(1, baseline);
-        previousVariations.push(summarizeWorkflowVariation({
+        previousVariations.push(summarizeMethodVariation({
             variation: 1,
             kind: "baseline",
             result: baseline,
             defaultTotalChecks: checks.length,
         }));
         if (baseline.passed) {
-            printWorkflowVariationSummary(previousVariations);
+            printMethodVariationSummary(previousVariations);
             printPostCompileNextStep({
                 compiledPath: options.compiledPath,
                 checks: checks.length,
@@ -360,10 +358,10 @@ export async function runConfiguredCompiledCompile(options) {
             for (let loopIndex = 1; loopIndex <= maxLoops; loopIndex += 1) {
                 console.log();
                 console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the Method.`));
-                const improvement = await runWorkflowImprovementLoop({
+                const improvement = await runMethodImprovementLoop({
                     executor: options.executor,
                     compiledPath: options.compiledPath,
-                    workflowId: resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
+                    methodId: resolveRequiredCompiledMethodFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
                     compiledConfig,
                     runId: improvementRunId,
                     loopIndex,
@@ -381,7 +379,7 @@ export async function runConfiguredCompiledCompile(options) {
                     console.log(chalk.yellow(`  ${improvement.summary}`));
                     continue;
                 }
-                const variation = await runWorkflowVariation({
+                const variation = await runMethodVariation({
                     executor: options.executor,
                     testExecutor: options.testExecutor,
                     compiledPath: options.compiledPath,
@@ -391,7 +389,6 @@ export async function runConfiguredCompiledCompile(options) {
                     preserveStageShells,
                     maxAttempts,
                     variationLabel: `Method variation ${loopIndex + 1}`,
-                    resetBeforeFirstAttempt: true,
                     runId: options.runId,
                     events: options.events,
                 });
@@ -401,15 +398,15 @@ export async function runConfiguredCompiledCompile(options) {
                     return false;
                 }
                 adoptVariationBest(loopIndex + 1, variation);
-                previousVariations.push(summarizeWorkflowVariation({
+                previousVariations.push(summarizeMethodVariation({
                     variation: loopIndex + 1,
                     kind: "edited",
                     result: variation,
                     defaultTotalChecks: checks.length,
                 }));
                 if (variation.passed) {
-                    printWorkflowVariationSummary(previousVariations);
-                    printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
+                    printMethodVariationSummary(previousVariations);
+                    printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
                     printPostCompileNextStep({
                         compiledPath: options.compiledPath,
                         checks: checks.length,
@@ -426,8 +423,8 @@ export async function runConfiguredCompiledCompile(options) {
         }
         process.exitCode = 1;
         console.log();
-        printWorkflowVariationSummary(previousVariations);
-        printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
+        printMethodVariationSummary(previousVariations);
+        printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
         if (maxLoops != null) {
             console.log(chalk.red(`  Portable Context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} Method-improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }

package/dist/cli/commands/compile.d.ts

@@ -1,6 +1,6 @@
 import * as p from "@clack/prompts";
 import { detectInterf } from "../../packages/project-model/interf.js";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { SourcePreparationConfig } 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";
@@ -23,11 +23,11 @@ export interface CompileCommandResult {
 export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
 export declare function resolveInteractiveCompileLoopOverrides(options: {
     compiledPath: string;
-    compiledConfig: SourceDatasetConfig | null;
+    compiledConfig: SourcePreparationConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 }): Promise<{
-    compiledConfig: SourceDatasetConfig | null;
+    compiledConfig: SourcePreparationConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 } | null>;