@interf/compiler 0.7.3 → 0.9.1

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

@@ -2,37 +2,37 @@ import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "no
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
-const DraftTruthCheckSchema = z.object({
+const DraftReadinessCheckSchema = z.object({
     question: z.string().min(1),
     answer: z.string().min(1),
 }).strict();
-const DraftTruthChecksSchema = z.array(DraftTruthCheckSchema).min(1).max(8);
-export function buildTruthCheckDraftPrompt(options) {
+const DraftReadinessChecksSchema = z.array(DraftReadinessCheckSchema).min(1).max(8);
+export function buildReadinessCheckDraftPrompt(options) {
     const normalizedAbout = options.about?.trim();
     const taskLines = normalizedAbout
         ? [
-            `Primary work: ${normalizedAbout}`,
-            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that work.",
-            "Prefer checks that would make a human confident the dataset is useful for that exact job.",
+            `Primary agent work: ${normalizedAbout}`,
+            "Draft readiness checks that directly measure whether a local agent can recover the agent-work-critical facts from the source files.",
+            "Prefer checks that would make a human confident the Preparation is useful for that exact job.",
         ]
         : [
-            "No primary work was provided.",
-            "Prefer broad, representative checks that reflect the most useful questions a human would verify from this source folder.",
+            "No primary agent work was provided.",
+            "Prefer broad, representative readiness checks that reflect the facts a human would verify from this Source Folder.",
         ];
     return [
-        "You are drafting Interf checks for a local source folder.",
+        "You are drafting Interf readiness checks for a local Source Folder.",
         "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
         "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.",
+        "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the files in this Source Folder.",
         "",
-        `Setup id: ${options.datasetName}`,
-        `Source folder: ${options.datasetPath}`,
+        `Preparation id: ${options.datasetName}`,
+        `Source Folder: ${options.datasetPath}`,
         ...taskLines,
         "",
         `Write exactly one JSON array to ${JSON.stringify(options.outputPath)}.`,
-        `Draft ${options.targetCount} checks unless the source folder is too small; in that case write fewer.`,
+        `Draft ${options.targetCount} checks unless the Source Folder is too small; in that case write fewer.`,
         "Each array item must be an object with exactly these keys:",
-        '- "question": a plain-English question answerable from this source folder',
+        '- "question": a plain-English question answerable from this Source Folder',
         '- "answer": the expected correct answer in plain English',
         "",
         "Quality bar:",
@@ -52,11 +52,11 @@ export function buildTruthCheckDraftPrompt(options) {
         "- Stop after writing the file.",
     ].join("\n");
 }
-export async function draftTruthChecks(options) {
+export async function draftReadinessChecks(options) {
     const tempDir = mkdtempSync(join(tmpdir(), "interf-draft-checks-"));
     const outputPath = join(tempDir, "checks.json");
     const promptPath = join(tempDir, "prompt.txt");
-    const prompt = buildTruthCheckDraftPrompt({
+    const prompt = buildReadinessCheckDraftPrompt({
         datasetName: options.datasetName,
         datasetPath: options.datasetPath,
         about: options.about,
@@ -67,6 +67,7 @@ export async function draftTruthChecks(options) {
     try {
         const code = await options.executor.execute(options.datasetPath, prompt, {
             completionCheck: () => existsSync(outputPath),
+            onStatus: options.onStatus,
         });
         if (!existsSync(outputPath)) {
             return {
@@ -86,7 +87,7 @@ export async function draftTruthChecks(options) {
                 error: `Draft checks were not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
             };
         }
-        const validated = DraftTruthChecksSchema.safeParse(parsed);
+        const validated = DraftReadinessChecksSchema.safeParse(parsed);
         if (!validated.success) {
             const detail = validated.error.issues[0]?.message ?? "invalid draft checks";
             return {

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

@@ -1,6 +1,7 @@
 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 { RunEventSink } from "../../packages/execution/events.js";
 export declare function runConfiguredCompiledCompile(options: {
     executor: WorkflowExecutor;
     testExecutor?: WorkflowExecutor | null;
@@ -11,4 +12,6 @@ export declare function runConfiguredCompiledCompile(options: {
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
     preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<boolean>;

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

@@ -11,10 +11,10 @@ import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../..
 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";
+import { printSavedTestOutcome, readinessPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
-    const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, workflowId, failedStage ?? "compile");
+    resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
+    const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, failedStage ?? "compile");
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
@@ -33,7 +33,7 @@ function bestVariationRestorePaths(compiledPath) {
         ".agents",
         ".cursor",
         ".interf/interf.json",
-        ".interf/workflow",
+        ".interf/method",
         ...zonePaths,
     ];
 }
@@ -78,17 +78,19 @@ async function runWorkflowVariation(options) {
                 const resetTarget = attempt > 1
                     ? `attempt ${attempt}/${options.maxAttempts}`
                     : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated portable-context 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 portable context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building portable context (${options.variationLabel})...`,
+                    ? `Building Portable Context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building Portable Context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Portable context ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Portable context ready for ${options.variationLabel}.`,
+                    ? `Portable Context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Portable Context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
+                runId: options.runId,
+                events: options.events,
             });
             if (!result.ok) {
                 printCompileFailure(options.compiledPath, result.failedStage);
@@ -123,7 +125,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved portable-context comparison after compile.",
+                    fatalError: "Could not run the saved Portable Context comparison after compile.",
                 };
             }
             console.log();
@@ -138,7 +140,7 @@ async function runWorkflowVariation(options) {
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Compiled context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                console.log(chalk.green(`  Portable Context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
                 printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
@@ -152,7 +154,7 @@ async function runWorkflowVariation(options) {
             }
             if (attempt < options.maxAttempts) {
                 console.log();
-                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same workflow.`));
+                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same Method.`));
             }
         }
         return {
@@ -178,22 +180,22 @@ async function runWorkflowVariation(options) {
     }
 }
 function summarizeWorkflowVariation(options) {
-    const passedQuestions = options.result.bestOutcome?.result.passedCases ?? 0;
-    const totalQuestions = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalQuestions;
+    const passedChecks = options.result.bestOutcome?.result.passedCases ?? 0;
+    const totalChecks = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalChecks;
     const summary = options.result.passed
-        ? `Passed ${passedQuestions}/${totalQuestions} questions.`
+        ? `Passed ${passedChecks}/${totalChecks} readiness checks.`
         : options.result.bestOutcome
-            ? `Best result: ${passedQuestions}/${totalQuestions} questions passed.`
+            ? `Best result: ${passedChecks}/${totalChecks} readiness checks passed.`
             : options.result.failedStage
                 ? `Compile failed at stage ${options.result.failedStage} before any saved comparison result.`
-                : "Workflow variation did not produce a passing result.";
+                : "Method variation did not produce a passing result.";
     return {
         variation: options.variation,
         kind: options.kind,
         attempts_run: Math.max(1, options.result.attemptsRun),
         passed: options.result.passed,
-        passed_questions: passedQuestions,
-        total_questions: totalQuestions,
+        passed_questions: passedChecks,
+        total_questions: totalChecks,
         ...(options.result.failedStage ? { failed_stage: options.result.failedStage } : {}),
         ...(options.result.bestOutcome ? { test_run_path: options.result.bestOutcome.runPath } : {}),
         ...(options.result.bestOutcome?.result.sandbox_path
@@ -213,39 +215,39 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
     }
 }
 function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Portable context: ${options.compiledPath}`));
+    console.log(chalk.dim(`  Portable Context: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add questions, then `interf test`."));
+        console.log(chalk.dim("  Next: run `interf` to add readiness checks, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the portable context agents will use, or run `interf test` if you also want a source-files-versus-portable-context comparison."));
+        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, 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 source files and portable context."));
+    console.log(chalk.dim("  Next: run `interf test` to compare source files and Portable Context."));
 }
-function formatVariationQuestionSummary(summary) {
+function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
 }
 function printWorkflowVariationSummary(summaries) {
     if (summaries.length === 0)
         return;
     console.log();
-    console.log(chalk.bold("  Workflow variation summary"));
+    console.log(chalk.bold("  Method variation summary"));
     console.log();
-    console.log("  | Variation | Kind | Questions | Result |");
+    console.log("  | Variation | Kind | Readiness checks | Result |");
     console.log("  | --- | --- | --- | --- |");
     for (const summary of summaries) {
-        console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
+        console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationReadinessSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
     }
 }
 function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
     if (bestVariation <= 1)
         return;
     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 portable context reuses that local workflow draft."));
+    console.log(chalk.dim(`  Best Method variation now lives in: ${workflowPackagePathForCompiled(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";
@@ -255,24 +257,26 @@ 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 questions. Building once without those loops."));
+        console.log(chalk.yellow("  Retry and self-improving modes need saved readiness checks. 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, check the portable context agents can use, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same Method variation, check the Portable Context agents can use, and stop early if it passes."));
         }
         else {
-            console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
+            console.log(chalk.dim("  Compilation mode: 1 attempt per Method variation."));
         }
         if (maxLoops != null) {
-            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
-            console.log(chalk.dim("  Interf will review failed runs, edit the workflow, and test new workflow variations."));
+            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} Method edits after retries fail.`));
+            console.log(chalk.dim("  Interf will review failed runs, edit the Method, and test new Method variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
         const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
             preserveStageShells,
+            runId: options.runId,
+            events: options.events,
         });
         if (!result.ok) {
             process.exitCode = 1;
@@ -327,7 +331,9 @@ export async function runConfiguredCompiledCompile(options) {
             executionProfile: options.executionProfile,
             preserveStageShells,
             maxAttempts,
-            variationLabel: "baseline workflow",
+            variationLabel: "baseline Method",
+            runId: options.runId,
+            events: options.events,
         });
         if (baseline.fatalError) {
             process.exitCode = 1;
@@ -339,7 +345,7 @@ export async function runConfiguredCompiledCompile(options) {
             variation: 1,
             kind: "baseline",
             result: baseline,
-            defaultTotalQuestions: checks.length,
+            defaultTotalChecks: checks.length,
         }));
         if (baseline.passed) {
             printWorkflowVariationSummary(previousVariations);
@@ -353,7 +359,7 @@ export async function runConfiguredCompiledCompile(options) {
         if (maxLoops != null) {
             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 workflow.`));
+                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the Method.`));
                 const improvement = await runWorkflowImprovementLoop({
                     executor: options.executor,
                     compiledPath: options.compiledPath,
@@ -365,7 +371,7 @@ export async function runConfiguredCompiledCompile(options) {
                     maxAttempts,
                     previousVariations,
                 });
-                console.log(chalk.dim(`  Workflow improvement shell: ${improvement.shellPath}`));
+                console.log(chalk.dim(`  Method improvement shell: ${improvement.shellPath}`));
                 if (improvement.status === "executor-failed") {
                     process.exitCode = 1;
                     console.log(chalk.red(`  ${improvement.summary}`));
@@ -384,8 +390,10 @@ export async function runConfiguredCompiledCompile(options) {
                     executionProfile: options.executionProfile,
                     preserveStageShells,
                     maxAttempts,
-                    variationLabel: `workflow variation ${loopIndex + 1}`,
+                    variationLabel: `Method variation ${loopIndex + 1}`,
                     resetBeforeFirstAttempt: true,
+                    runId: options.runId,
+                    events: options.events,
                 });
                 if (variation.fatalError) {
                     process.exitCode = 1;
@@ -397,7 +405,7 @@ export async function runConfiguredCompiledCompile(options) {
                     variation: loopIndex + 1,
                     kind: "edited",
                     result: variation,
-                    defaultTotalQuestions: checks.length,
+                    defaultTotalChecks: checks.length,
                 }));
                 if (variation.passed) {
                     printWorkflowVariationSummary(previousVariations);
@@ -414,20 +422,20 @@ export async function runConfiguredCompiledCompile(options) {
         if (bestSnapshotPath && bestVariation > 0) {
             restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing portable context 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(`  Portable context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            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"}.`));
         }
         else {
-            console.log(chalk.red(`  Portable context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Portable Context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt test pass rate: ${questionPassRate(bestOutcome)}%.`));
+            console.log(chalk.dim(`  Best attempt readiness-check pass rate: ${readinessPassRate(bestOutcome)}%.`));
         }
         printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;

package/dist/cli/commands/compile.js

@@ -4,20 +4,25 @@ import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../..
 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 { resolveConfiguredPreparationSelection } from "./preparation-selection.js";
 import { promptCompileLoopSelection, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { runConfiguredCompiledCompile } from "./compile-controller.js";
+import { submitCompileRunToLocalService, waitForLocalCompileRun, } from "../../packages/local-service/index.js";
+import { resolveCommandControlPath } from "./control-path.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build portable context agents can use and optionally run retry or self-improving compile loops",
-    builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
+    describe: "Prepare files and write Portable Context agents can use",
+    builder: (yargs) => addExecutionProfileOptions(yargs).option("preparation", {
+        type: "string",
+        describe: "Preparation id to compile when this Source Folder has more than one Preparation",
+    }).option("max-attempts", {
         type: "number",
-        describe: "Retry compile and test the same workflow until the dataset passes or reaches this total attempt limit",
+        describe: "Retry the prepare run and run saved readiness checks with the same Method until the Preparation is ready 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",
+        describe: "After retries fail, let Interf edit the Method and run saved readiness checks on new Method variations for this Preparation up to this loop limit",
     }).option("keep-stage-shells", {
         type: "boolean",
         default: false,
@@ -42,8 +47,9 @@ function readHintedSourcePath(argv) {
         : null;
 }
 function readRequestedDatasetName(argv) {
-    return typeof argv.dataset === "string" && argv.dataset.trim().length > 0
-        ? argv.dataset.trim()
+    const raw = argv.preparation;
+    return typeof raw === "string" && raw.trim().length > 0
+        ? raw.trim()
         : null;
 }
 function shouldSkipCompileConfirm(argv) {
@@ -69,7 +75,7 @@ export async function runCompileCommand(argv = {}, deps = {}) {
     let compiledPath = null;
     const hintedSourcePath = readHintedSourcePath(argv);
     const detected = hintedSourcePath ? null : helpers.detectInterf(process.cwd());
-    let sourcePath = hintedSourcePath ?? process.cwd();
+    let sourcePath = hintedSourcePath ?? resolveCommandControlPath();
     let compiledConfig = null;
     const requestedDatasetName = readRequestedDatasetName(argv);
     const hintedDatasetConfig = (argv.datasetConfig ?? null);
@@ -82,7 +88,7 @@ export async function runCompileCommand(argv = {}, deps = {}) {
             ?? sourceDatasetConfigFromInterfConfig(detected.config);
         if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await helpers.confirm({
-                message: `Compile dataset "${detected.config.name}" now?`,
+                message: `Prepare files for Preparation "${detected.config.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
@@ -91,32 +97,32 @@ export async function runCompileCommand(argv = {}, deps = {}) {
     }
     else {
         const selectedCompiled = requestedDatasetName || hintedDatasetConfig
-            ? resolveConfiguredDatasetSelection({
+            ? resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedDatasetName,
-                hintedDatasetConfig,
+                requestedPreparationName: requestedDatasetName,
+                hintedPreparationConfig: hintedDatasetConfig,
             })
             : await helpers.chooseCompiledConfigToBuild({
                 sourcePath,
-                selectMessage: "Which source folder setup do you want to compile?",
+                selectMessage: "Which saved Preparation do you want to compile?",
             });
         if (selectedCompiled === undefined)
             return null;
         if (!selectedCompiled) {
             process.exitCode = 1;
             if (requestedDatasetName) {
-                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."));
+                console.log(chalk.red(`  Preparation "${requestedDatasetName}" is not saved in this Source Folder.`));
+                console.log(chalk.dim("  Run `interf list` to see the saved Preparations."));
             }
             else {
-                console.log(chalk.red("  No saved setups are configured for this folder yet."));
+                console.log(chalk.red("  No saved Preparations are configured for this Source Folder yet."));
                 console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
             }
             return null;
         }
         if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
             const confirmed = await helpers.confirm({
-                message: `Compile dataset "${selectedCompiled.name}" now?`,
+                message: `Prepare files for Preparation "${selectedCompiled.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
@@ -125,7 +131,7 @@ export async function runCompileCommand(argv = {}, deps = {}) {
         compiledConfig = selectedCompiled;
         compiledPath = helpers.ensureCompiledFromConfig(sourcePath, selectedCompiled);
         if (!skipDatasetBanner) {
-            console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
+            console.log(chalk.dim(`  Preparation: ${selectedCompiled.name}`));
         }
     }
     let maxAttemptsOverride = null;
@@ -155,6 +161,56 @@ export async function runCompileCommand(argv = {}, deps = {}) {
         maxAttemptsOverride,
         maxLoopsOverride,
     });
+    if (argv.skipService !== true && compiledConfig) {
+        const submitted = await submitCompileRunToLocalService({
+            projectPath: sourcePath,
+            request: {
+                preparation: compiledConfig.name,
+                ...(compiledConfig.method ? { method: compiledConfig.method } : {}),
+                ...(maxAttemptsOverride != null ? { max_attempts: maxAttemptsOverride } : {}),
+                ...(maxLoopsOverride != null ? { max_loops: maxLoopsOverride } : {}),
+                preserve_stage_shells: readStageShellRetentionMode(argv),
+            },
+        });
+        if (submitted) {
+            console.log(chalk.dim(`  Visible in Interf: ${submitted.serviceUrl}/`));
+            let lastStatus = "";
+            let lastStage = "";
+            const completed = await waitForLocalCompileRun({
+                serviceUrl: submitted.serviceUrl,
+                runId: submitted.resource.run.run_id,
+                onUpdate(resource) {
+                    const activeStage = resource.run.stages.find((stage) => stage.status === "running")
+                        ?? [...resource.run.stages].reverse().find((stage) => stage.status === "succeeded" || stage.status === "failed")
+                        ?? null;
+                    const statusKey = `${resource.run.status}:${activeStage?.stage_id ?? ""}:${activeStage?.status ?? ""}`;
+                    if (statusKey === `${lastStatus}:${lastStage}`)
+                        return;
+                    lastStatus = resource.run.status;
+                    lastStage = `${activeStage?.stage_id ?? ""}:${activeStage?.status ?? ""}`;
+                    if (activeStage) {
+                        console.log(chalk.dim(`  ${activeStage.stage_label ?? activeStage.stage_id}: ${activeStage.status}`));
+                    }
+                    else {
+                        console.log(chalk.dim(`  Prepare run: ${resource.run.status}`));
+                    }
+                },
+            });
+            if (completed.run.status !== "succeeded") {
+                process.exitCode = 1;
+                const failure = completed.run.stages.find((stage) => stage.status === "failed");
+                console.log(chalk.red(`  Prepare run ${completed.run.status}.`));
+                if (failure?.failure)
+                    console.log(chalk.red(`  ${failure.failure}`));
+                return null;
+            }
+            console.log(chalk.green("  Portable Context ready."));
+            return {
+                compiledPath: completed.run.portable_context_path,
+                testedDuringCompile,
+            };
+        }
+    }
     const executionProfile = executionProfileFromArgv(argv);
     const { executor, error } = await helpers.resolveOrConfigureLocalExecutor({
         executionProfile,
@@ -231,10 +287,10 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
             initialMaxAttempts: savedCompiledConfig.max_attempts,
             initialMaxLoops: savedCompiledConfig.max_loops,
             intro: [
-                `Workflow: ${savedCompiledConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
-                "This selection applies to this compile run only. It does not change the saved dataset setup.",
+                `Method: ${savedCompiledConfig.method ?? savedCompiledConfig.workflow ?? currentConfig?.method ?? currentConfig?.workflow ?? "interf-default"}`,
+                "This selection applies to this prepare run only. It does not change the saved Preparation.",
             ],
-            message: "How should this compile run?",
+            message: "How should this prepare run work?",
         });
         if (overrideSelection === null)
             return null;
@@ -249,17 +305,17 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         };
     }
     const savedMode = await p.select({
-        message: "Which compile mode should this run use?",
+        message: "Which prepare mode should this run use?",
         options: [
             {
                 value: "saved",
-                label: "Use saved compile mode (Recommended)",
+                label: "Use saved prepare mode (Recommended)",
                 hint: `${savedCompiledConfig.max_loops ? "Self-improving" : savedCompiledConfig.max_attempts && savedCompiledConfig.max_attempts > 1 ? "Retry" : "Single attempt"} · ${formatCompileModeHint(savedCompiledConfig)}`,
             },
             {
                 value: "override",
                 label: "Change it for this run only",
-                hint: "Keep the saved dataset setup unchanged",
+                hint: "Keep the saved Preparation unchanged",
             },
         ],
     });
@@ -277,10 +333,10 @@ export async function resolveInteractiveCompileLoopOverrides(options) {
         initialMaxAttempts: savedCompiledConfig.max_attempts,
         initialMaxLoops: savedCompiledConfig.max_loops,
         intro: [
-            `Workflow: ${savedCompiledConfig.workflow ?? currentConfig?.workflow ?? "interf"}`,
-            "This applies to this compile run only. It does not change the saved dataset setup.",
+            `Method: ${savedCompiledConfig.method ?? savedCompiledConfig.workflow ?? currentConfig?.method ?? currentConfig?.workflow ?? "interf-default"}`,
+            "This applies to this prepare run only. It does not change the saved Preparation.",
         ],
-        message: "Override the compile mode for this run",
+        message: "Override the prepare mode for this run",
     });
     if (selection === null)
         return null;

package/dist/cli/commands/compiled-flow.d.ts

@@ -1,6 +1,7 @@
 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";
+import type { RunEventSink } from "../../packages/execution/events.js";
 export interface SavedDatasetEntry {
     config: SourceDatasetConfig;
     path: string | null;
@@ -19,4 +20,6 @@ export declare function compileCompiledWithReporter(executor: WorkflowExecutor,
     heading?: string;
     successMessage?: string;
     preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<CompiledCompileResult>;