@interf/compiler 0.9.3 → 0.9.5

package/dist/cli/commands/init.js

@@ -3,18 +3,19 @@ import * as p from "@clack/prompts";
 import { existsSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, isAbsolute, relative, resolve } from "node:path";
-import { assertCompiledContainer, detectInterf, ensurePortableContextScaffold, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { SOURCE_FOLDER_CONFIG_PATH, configuredSourceFolderPath, loadSourceFolderConfig, resolveConfiguredSourceFolderPath, saveSourceFolderConfig, syncCompiledInterfConfigFromSourcePreparationConfig, upsertSourcePreparationConfig, } from "../../packages/project-model/source-config.js";
+import { assertCompiledContainer, detectInterf, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { SOURCE_FOLDER_CONFIG_PATH, configuredSourceFolderPath, loadSourceFolderConfig, resolveConfiguredSourceFolderPath, saveSourceFolderConfig, } from "../../packages/project-model/source-config.js";
 import { defaultPreparationNameForPath, } from "../../packages/project-model/source-folders.js";
 import { DEFAULT_PREPARATION_NAME, describeCompileLoopSelection, listSourceFolderChoices, promptSingleCompiledConfig, } from "./source-config-wizard.js";
 import { chooseOrCreateCompiledMethodForPreparation, createMethodWizard, } from "./create-method-wizard.js";
 import { seedLocalDefaultMethod } from "../../packages/method-package/local-methods.js";
-import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedPreparationEntries, } from "./compiled-flow.js";
-import { readCurrentSavedTestComparison, } from "./test-flow.js";
+import { listSavedPreparationEntries, findBuiltPortableContextPath, findSavedPreparationConfig, } from "../../packages/project-model/preparation-entries.js";
+import { readCurrentSavedReadinessCheckRun, } from "../../packages/testing/readiness-check-run.js";
 import { runCompileCommand } from "./compile.js";
 import { runTestCommand } from "./test.js";
 import { defaultInterfInstanceRoot, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
 import { runWebCommand } from "./web.js";
+import { savePreparationThroughServiceAction } from "./preparation-action.js";
 function displayPath(path) {
     const resolvedPath = resolve(path);
     const cwd = process.cwd();
@@ -212,27 +213,27 @@ function printPreparationSummary(options) {
     });
     if (prepareMode !== "Prepare once.")
         p.log.info(`Prepare mode: ${prepareMode}`);
-    if (options.latestComparison?.raw && options.latestComparison?.compiled) {
-        p.log.info(`Latest saved comparison: source files ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}, Portable Context ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+    if (options.latestReadiness?.raw && options.latestReadiness?.compiled) {
+        p.log.info(`Latest readiness evidence: source files ${options.latestReadiness.raw.passed_cases}/${options.latestReadiness.raw.total_cases}, Portable Context ${options.latestReadiness.compiled.passed_cases}/${options.latestReadiness.compiled.total_cases}.`);
     }
-    else if (options.latestComparison?.raw) {
-        p.log.info(`Latest saved source-files run: ${options.latestComparison.raw.passed_cases}/${options.latestComparison.raw.total_cases}.`);
+    else if (options.latestReadiness?.raw) {
+        p.log.info(`Latest source-files readiness run: ${options.latestReadiness.raw.passed_cases}/${options.latestReadiness.raw.total_cases}.`);
     }
-    else if (options.latestComparison?.compiled) {
-        p.log.info(`Latest Portable Context run: ${options.latestComparison.compiled.passed_cases}/${options.latestComparison.compiled.total_cases}.`);
+    else if (options.latestReadiness?.compiled) {
+        p.log.info(`Latest Portable Context readiness run: ${options.latestReadiness.compiled.passed_cases}/${options.latestReadiness.compiled.total_cases}.`);
     }
-    else if (options.latestComparisonStale) {
+    else if (options.latestReadinessStale) {
         p.log.info("Saved readiness results are stale for the current checks.");
     }
     if (options.sourcePath !== process.cwd()) {
         p.log.info(`Interf Workspace: ${displayPath(options.sourcePath)}`);
     }
 }
-async function promptPreparationAction(preparation, built, latestComparison) {
+async function promptPreparationAction(preparation, built, latestReadiness) {
     const options = [];
-    const hasSavedRawBaseline = Boolean(latestComparison?.raw);
-    const latestRawPasses = latestComparison?.raw &&
-        latestComparison.raw.passed_cases === latestComparison.raw.total_cases;
+    const hasSavedRawBaseline = Boolean(latestReadiness?.raw);
+    const latestRawPasses = latestReadiness?.raw &&
+        latestReadiness.raw.passed_cases === latestReadiness.raw.total_cases;
     const compileOption = {
         value: "compile",
         label: built ? "Prepare again" : "Prepare files",
@@ -251,9 +252,7 @@ async function promptPreparationAction(preparation, built, latestComparison) {
         label: "Open Interf UI",
         hint: "Start the local UI and API for this Interf Workspace",
     };
-    if (built) {
-        options.push(webOption);
-    }
+    options.push(webOption);
     if (preparation.checks.length > 0) {
         const testOption = {
             value: "test",
@@ -303,21 +302,21 @@ async function promptPreparationAction(preparation, built, latestComparison) {
         return null;
     return selected;
 }
-function printPreparationRecommendation(preparation, built, latestComparison) {
+function printPreparationRecommendation(preparation, built, latestReadiness) {
     if (preparation.checks.length === 0) {
         return;
     }
     if (!built) {
-        if (latestComparison?.raw) {
-            p.log.info(latestComparison.raw.passed_cases === latestComparison.raw.total_cases
-                ? `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Prepare files if you want a side-by-side comparison.`
-                : `Latest source-files run: ${latestComparison.raw.passed_cases}/${latestComparison.raw.total_cases}. Some readiness checks still fail on the source files. Prepare files if you want Interf to process this data and run the same checks.`);
+        if (latestReadiness?.raw) {
+            p.log.info(latestReadiness.raw.passed_cases === latestReadiness.raw.total_cases
+                ? `Latest source-files readiness run: ${latestReadiness.raw.passed_cases}/${latestReadiness.raw.total_cases}. Prepare files when you want Portable Context for the same agent work.`
+                : `Latest source-files readiness run: ${latestReadiness.raw.passed_cases}/${latestReadiness.raw.total_cases}. Some readiness checks still fail on the source files. Prepare files if you want Interf to process this data and run the same checks.`);
             return;
         }
         p.log.info("Recommended first step: choose a Method and prepare files.");
         return;
     }
-    p.log.info("Recommended first step: compare the source-files baseline and Portable Context.");
+    p.log.info("Recommended first step: run readiness checks against source files and Portable Context.");
 }
 async function promptPostBaselineAction(rows) {
     const status = currentRunTargetStatus(rows, "raw");
@@ -369,7 +368,7 @@ async function promptPostBaselineAction(rows) {
 }
 async function chooseCompiledForWizard(options) {
     if (options.fixedCompiledName) {
-        return findSavedCompiledConfig(options.sourcePath, options.fixedCompiledName);
+        return findSavedPreparationConfig(options.sourcePath, options.fixedCompiledName);
     }
     const savedEntries = listSavedPreparationEntries(options.sourcePath);
     if (savedEntries.length === 0)
@@ -400,7 +399,7 @@ async function chooseCompiledForWizard(options) {
         return null;
     if (selected === "__new__")
         return "__new__";
-    return findSavedCompiledConfig(options.sourcePath, String(selected));
+    return findSavedPreparationConfig(options.sourcePath, String(selected));
 }
 async function promptCompiledSetup(options) {
     const savedConfig = loadSourceFolderConfig(options.sourcePath);
@@ -417,7 +416,6 @@ async function promptCompiledSetup(options) {
         return null;
     const methodChoice = await chooseOrCreateCompiledMethodForPreparation(options.sourcePath, compiledConfig, {
         currentMethodId: options.initial?.method ?? "interf-default",
-        executionProfile: options.executionProfile,
     });
     if (!methodChoice || p.isCancel(methodChoice))
         return null;
@@ -426,16 +424,10 @@ async function promptCompiledSetup(options) {
         ...compiledConfig,
         method: methodId,
     };
-    upsertSourcePreparationConfig(options.sourcePath, compiledConfigWithMethod, {
-        ...(options.fixedName ? { matchName: options.fixedName } : {}),
+    await savePreparationThroughServiceAction({
+        sourcePath: options.sourcePath,
+        preparation: compiledConfigWithMethod,
     });
-    const builtCompiledPath = findBuiltCompiledPath(options.sourcePath, compiledConfigWithMethod.name);
-    if (builtCompiledPath) {
-        syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, compiledConfigWithMethod);
-    }
-    else {
-        ensurePortableContextScaffold(options.sourcePath, compiledConfigWithMethod.name, compiledConfigWithMethod.method ?? "interf-default");
-    }
     console.log();
     console.log(chalk.green(`  ✓ Saved Preparation in ${SOURCE_FOLDER_CONFIG_PATH}`));
     console.log(chalk.dim(`  Interf Workspace: ${options.sourcePath}`));
@@ -458,8 +450,8 @@ export async function compileSelectedCompiled(sourcePath, compiledConfig, deps =
     });
 }
 async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
-    const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
-    const { comparison: latestComparison, stale: latestComparisonStale, } = readCurrentSavedTestComparison({
+    const builtCompiledPath = findBuiltPortableContextPath(sourcePath, compiledConfig.name);
+    const { readinessRun: latestReadiness, stale: latestReadinessStale, } = readCurrentSavedReadinessCheckRun({
         projectPath: sourcePath,
         preparationName: compiledConfig.name,
         checks: compiledConfig.checks,
@@ -469,11 +461,11 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         preparation: compiledConfig,
         built: Boolean(builtCompiledPath),
         builtCompiledPath,
-        latestComparison,
-        latestComparisonStale,
+        latestReadiness,
+        latestReadinessStale,
     });
-    printPreparationRecommendation(compiledConfig, Boolean(builtCompiledPath), latestComparison);
-    const action = await promptPreparationAction(compiledConfig, Boolean(builtCompiledPath), latestComparison);
+    printPreparationRecommendation(compiledConfig, Boolean(builtCompiledPath), latestReadiness);
+    const action = await promptPreparationAction(compiledConfig, Boolean(builtCompiledPath), latestReadiness);
     if (!action)
         return;
     if (action === "done") {
@@ -493,16 +485,11 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
                 ...compiledConfig,
                 method: methodId,
             };
-            upsertSourcePreparationConfig(sourcePath, nextConfig, {
-                matchName: compiledConfig.name,
+            await savePreparationThroughServiceAction({
+                sourcePath,
+                preparation: nextConfig,
+                setupMode: "select-method",
             });
-            const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
-            if (builtCompiledPath) {
-                syncCompiledInterfConfigFromSourcePreparationConfig(builtCompiledPath, nextConfig);
-            }
-            else {
-                ensurePortableContextScaffold(sourcePath, nextConfig.name, nextConfig.method ?? "interf-default");
-            }
             p.log.info(`Assigned Method "${methodId}" to Preparation "${compiledConfig.name}".`);
             p.log.info("Next: run `interf compile`, then `interf test`.");
         }
@@ -598,7 +585,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         }
         if (compileResult.testedDuringCompile) {
             p.log.info("This prepare run already checked the Portable Context on the saved readiness checks.");
-            p.log.info("Run `interf test` later if you want a fresh side-by-side comparison summary.");
+            p.log.info("Run `interf test` later if you want fresh readiness evidence for source files and Portable Context.");
             return;
         }
         await runTestCommand({
@@ -620,7 +607,7 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         }
         const runCompiledTest = await p.confirm({
             message: compileResult.testedDuringCompile
-                ? "Run a fresh source-files versus Portable Context comparison now?"
+                ? "Run fresh readiness checks against source files and Portable Context now?"
                 : builtCompiledPath
                     ? "Run readiness checks on source files and Portable Context now?"
                     : "Run readiness checks on source files and Portable Context now?",

package/dist/cli/commands/list.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { listSavedPreparationEntries } from "./compiled-flow.js";
+import { listSavedPreparationEntries, } from "../../packages/project-model/preparation-entries.js";
 import { resolveCommandControlPath } from "./control-path.js";
 import { resolveMethodId } from "../../packages/methods/method-resolution.js";
 export const listCommand = {

package/dist/cli/commands/preparation-action.d.ts

@@ -0,0 +1,8 @@
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import type { PreparationSetupResult } from "../../packages/local-service/index.js";
+export declare function savePreparationThroughServiceAction(options: {
+    preparation: SourcePreparationConfig;
+    prepareAfterSetup?: boolean;
+    setupMode?: "create" | "select-method";
+    sourcePath: string;
+}): Promise<PreparationSetupResult>;

package/dist/cli/commands/preparation-action.js

@@ -0,0 +1,29 @@
+import { submitPreparationSetupToLocalService, } from "../../packages/local-service/index.js";
+import { PreparationSetupActionValuesSchema, preparationSetupRequestFromActionValues, } from "../../packages/local-service/action-definitions.js";
+function preparationSetupRequest(preparation, options = {}) {
+    const values = PreparationSetupActionValuesSchema.parse({
+        name: preparation.name,
+        path: preparation.path,
+        about: preparation.about ?? `Preparation ${preparation.name}`,
+        method: preparation.method ?? "interf-default",
+        checks: preparation.checks,
+        ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
+        ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
+        prepare_after_setup: options.prepareAfterSetup ?? false,
+        ...(options.setupMode ? { setup_mode: options.setupMode } : {}),
+    });
+    return preparationSetupRequestFromActionValues(values);
+}
+export async function savePreparationThroughServiceAction(options) {
+    const submitted = await submitPreparationSetupToLocalService({
+        projectPath: options.sourcePath,
+        request: preparationSetupRequest(options.preparation, {
+            prepareAfterSetup: options.prepareAfterSetup,
+            setupMode: options.setupMode,
+        }),
+    });
+    if (!submitted) {
+        throw new Error("Interf local service is not running. Start `interf web`, then retry so the Preparation change is visible in Interf.");
+    }
+    return submitted.result;
+}

package/dist/cli/commands/preparation-picker.d.ts

@@ -0,0 +1,5 @@
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+export declare function choosePreparationConfig(options: {
+    sourcePath: string;
+    selectMessage: string;
+}): Promise<SourcePreparationConfig | null | undefined>;

package/dist/cli/commands/preparation-picker.js

@@ -0,0 +1,36 @@
+import * as p from "@clack/prompts";
+import { listSavedPreparationEntries, } from "../../packages/project-model/preparation-entries.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
+function formatSavedPreparationHint(entry) {
+    const config = entry.config;
+    const checkCount = config.checks.length;
+    const methodHint = `Method ${resolveMethodId(config)}${entry.localDraft ? " (local draft)" : ""}`;
+    if (config.about)
+        return `${config.path} · ${config.about} · ${methodHint}`;
+    if (checkCount === 0)
+        return `${config.path} · No readiness checks yet · ${methodHint}`;
+    return `${config.path} · ${checkCount} readiness check${checkCount === 1 ? "" : "s"} · ${methodHint}`;
+}
+export async function choosePreparationConfig(options) {
+    const savedEntries = listSavedPreparationEntries(options.sourcePath);
+    if (savedEntries.length === 0) {
+        return null;
+    }
+    if (savedEntries.length === 1) {
+        return savedEntries[0]?.config ?? null;
+    }
+    const selected = await p.select({
+        message: options.selectMessage,
+        options: savedEntries.map((entry) => ({
+            value: entry.config.name,
+            label: entry.config.name,
+            hint: [
+                formatSavedPreparationHint(entry),
+                entry.path ? "Portable Context available" : "Portable Context not built yet",
+            ].join(" · "),
+        })),
+    });
+    if (p.isCancel(selected))
+        return undefined;
+    return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
+}

package/dist/cli/commands/preparation-selection.js

@@ -1,4 +1,4 @@
-import { findSavedCompiledConfig } from "./compiled-flow.js";
+import { findSavedPreparationConfig, } from "../../packages/project-model/preparation-entries.js";
 export function resolveConfiguredPreparationSelection(options) {
     if (options.hintedPreparationConfig &&
         (!options.requestedPreparationName || options.hintedPreparationConfig.name === options.requestedPreparationName)) {
@@ -7,5 +7,5 @@ export function resolveConfiguredPreparationSelection(options) {
     if (!options.requestedPreparationName) {
         return null;
     }
-    return findSavedCompiledConfig(options.sourcePath, options.requestedPreparationName);
+    return findSavedPreparationConfig(options.sourcePath, options.requestedPreparationName);
 }

package/dist/cli/commands/reset.js

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import { detectInterf } from "../../packages/project-model/interf.js";
-import { resetCompiledGeneratedState } from "../../packages/compiler/reset.js";
+import { submitResetToLocalService, } from "../../packages/local-service/index.js";
+import { resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 export const resetCommand = {
     command: "reset <scope>",
     describe: "Reset generated Portable Context state while keeping source files and the local Method package",
@@ -15,8 +16,18 @@ export const resetCommand = {
             console.log(chalk.red("Run this from inside a Portable Context."));
             return;
         }
-        const compiledPath = detected.path;
-        resetCompiledGeneratedState(compiledPath, argv.scope);
-        console.log(chalk.green("  Portable Context reset complete."));
+        const submitted = await submitResetToLocalService({
+            projectPath: resolveSourceControlPath(detected.path),
+            request: {
+                preparation: detected.config.name,
+                scope: argv.scope,
+            },
+        });
+        if (!submitted) {
+            process.exitCode = 1;
+            console.log(chalk.red("Interf local service is not running. Start `interf web`, then retry reset so the mutation is visible through the service API."));
+            return;
+        }
+        console.log(chalk.green(`  ${submitted.result.message}`));
     },
 };

package/dist/cli/commands/service-action-flow.d.ts

@@ -0,0 +1,9 @@
+import { type ActionProposalCreateRequest, type ActionProposalResource } from "../../packages/local-service/index.js";
+export type ApprovedActionResult = {
+    proposal: ActionProposalResource;
+    serviceUrl: string | null;
+};
+export declare function approveActionThroughService(options: {
+    request: ActionProposalCreateRequest;
+    sourcePath: string;
+}): Promise<ApprovedActionResult>;

package/dist/cli/commands/service-action-flow.js

@@ -0,0 +1,19 @@
+import { approveActionProposalInLocalService, } from "../../packages/local-service/index.js";
+export async function approveActionThroughService(options) {
+    const serviceProposal = await approveActionProposalInLocalService({
+        projectPath: options.sourcePath,
+        request: {
+            ...options.request,
+            client_origin: options.request.client_origin && options.request.client_origin !== "unknown"
+                ? options.request.client_origin
+                : "cli",
+        },
+    });
+    if (serviceProposal) {
+        return {
+            proposal: serviceProposal.resource,
+            serviceUrl: serviceProposal.serviceUrl,
+        };
+    }
+    throw new Error("Interf local service is not running for this Workspace. Start it with `interf web`, then rerun this action so the proposal and run are visible in Interf.");
+}

package/dist/cli/commands/source-config-wizard.d.ts

@@ -2,7 +2,6 @@ import { type SourcePreparationConfig, type SourceReadinessCheck } from "../../p
 export declare const DEFAULT_PREPARATION_NAME = "default";
 export declare const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
 export declare const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
 export declare const DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER = "./source-files";
 export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export declare const DEFAULT_SELF_IMPROVING_LOOPS = 3;

package/dist/cli/commands/source-config-wizard.js

@@ -2,12 +2,10 @@ import * as p from "@clack/prompts";
 import { sourceConfig as projectSourceConfig, sourceFolders as projectSourceFolders, } from "../../packages/project-model/index.js";
 import { slugify } from "../../packages/shared/naming.js";
 import { submitReadinessCheckDraftToLocalService, } from "../../packages/local-service/index.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { draftReadinessChecks } from "./check-draft.js";
+import { buildCreatePreparationActionDefinition, } from "../../packages/local-service/action-definitions.js";
 export const DEFAULT_PREPARATION_NAME = "default";
 export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "An agent-work-critical check you can already verify from this Source Folder";
 export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board prep from these files, chart reads from this report, or tax review from these exports.";
 export const DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER = "./source-files";
 export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
@@ -81,10 +79,20 @@ async function promptSourceFolderPath(options) {
     return normalizeSourceFolderPathForConfig(options.projectPath, String(sourceFolderPath));
 }
 export function preparationAboutPromptMessage(introStyle) {
-    if (introStyle === "edit") {
-        return "What agent work should this Preparation stay focused on?";
-    }
-    return "What agent work should this Preparation help with?";
+    void introStyle;
+    return createPreparationActionField("about").label;
+}
+function createPreparationActionField(name) {
+    const definition = buildCreatePreparationActionDefinition({
+        existingNames: [],
+        methods: [],
+        sourcePath: DEFAULT_SOURCE_FOLDER_PATH_PLACEHOLDER,
+        suggestedName: DEFAULT_PREPARATION_NAME,
+    });
+    const field = definition.fields.find((candidate) => candidate.name === name);
+    if (!field)
+        throw new Error(`Create Preparation action field missing: ${name}`);
+    return field;
 }
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -208,7 +216,7 @@ async function promptDraftReadinessChecks(options) {
                 lastServiceStatus = statusKey;
                 p.log.info(activeStep
                     ? `${activeStep.label}: ${activeStep.status}`
-                    : `Readiness-check draft run: ${job.status}`);
+                    : `Draft readiness checks run: ${job.status}`);
             },
         });
         const drafted = serviceRun
@@ -216,50 +224,30 @@ async function promptDraftReadinessChecks(options) {
                 checks: serviceRun.result?.checks ?? null,
                 error: serviceRun.error,
             }
-            : await (async () => {
-                const resolved = await resolveOrConfigureLocalExecutor({
-                    preflight: true,
-                    purpose: "draft",
-                });
-                if (!resolved.executor) {
-                    if (resolved.cancelled)
-                        return null;
-                    p.log.error(resolved.error ?? "No local agent detected for readiness-check drafting.");
-                    const manualChoice = await p.select({
-                        message: "How do you want to continue?",
-                        options: [
-                            {
-                                value: "manual",
-                                label: "Add readiness checks manually",
-                                hint: "Write the checks and expected answers yourself",
-                            },
-                            {
-                                value: "skip",
-                                label: "Skip for now",
-                                hint: "Save this Preparation without readiness checks",
-                            },
-                        ],
-                    });
-                    if (p.isCancel(manualChoice))
-                        return null;
-                    return manualChoice === "manual"
-                        ? "manual"
-                        : "skip";
-                }
-                return draftReadinessChecks({
-                    preparationName: options.preparationName,
-                    sourceFolderPath: resolvedSourceFolderPath,
-                    about: options.about,
-                    executor: resolved.executor,
-                    targetCount: 4,
-                });
-            })();
+            : "service-missing";
         if (drafted === null)
             return null;
-        if (drafted === "manual")
-            return "manual";
-        if (drafted === "skip")
-            return [];
+        if (drafted === "service-missing") {
+            p.log.error("Interf local service is not running. Start `interf web` to create visible runs for drafting readiness checks.");
+            const manualChoice = await p.select({
+                message: "How do you want to continue?",
+                options: [
+                    {
+                        value: "manual",
+                        label: "Add readiness checks manually",
+                        hint: "Write the checks and expected answers yourself",
+                    },
+                    {
+                        value: "skip",
+                        label: "Skip for now",
+                        hint: "Save this Preparation without readiness checks",
+                    },
+                ],
+            });
+            if (p.isCancel(manualChoice))
+                return null;
+            return manualChoice === "manual" ? "manual" : [];
+        }
         if (!drafted.checks) {
             p.log.error(drafted.error ?? "Could not draft readiness checks from this Source Folder.");
             const retryMode = await p.select({
@@ -612,9 +600,10 @@ export async function promptSingleCompiledConfig(options = {}) {
     }
     if (!name) {
         const suggestedName = defaultPreparationNameForPath(normalizedSourceFolderPath);
+        const nameField = createPreparationActionField("name");
         const rawName = await p.text({
-            message: "Preparation name?",
-            placeholder: suggestedName,
+            message: nameField.label,
+            placeholder: nameField.placeholder ?? suggestedName,
             initialValue: suggestedName,
             validate: (value) => (value.trim().length === 0 ? "Preparation name is required" : undefined),
         });
@@ -634,9 +623,10 @@ export async function promptSingleCompiledConfig(options = {}) {
         ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
     };
     if (!(options.skipAboutPrompt && initial?.about)) {
+        const aboutField = createPreparationActionField("about");
         const aboutInput = await p.text({
             message: preparationAboutPromptMessage(introStyle),
-            placeholder: DEFAULT_COMPILED_ABOUT_PLACEHOLDER,
+            placeholder: aboutField.placeholder,
             initialValue: about ?? "",
         });
         if (p.isCancel(aboutInput))