@interf/compiler 0.9.4 → 0.13.0

package/dist/packages/local-service/runtime-event-applier.js

@@ -0,0 +1,177 @@
+import { uniqueArtifacts } from "./run-observability.js";
+export function applyEventToCompileRun(run, event) {
+    const now = event.timestamp;
+    const stageFor = (stageId) => {
+        const existing = run.stages.find((stage) => stage.stage_id === stageId);
+        if (existing)
+            return existing;
+        const created = {
+            run_id: run.run_id,
+            stage_id: stageId,
+            status: "queued",
+            artifacts: [],
+        };
+        run.stages.push(created);
+        return created;
+    };
+    const updateStage = (stageId, patch) => {
+        const current = stageFor(stageId);
+        Object.assign(current, patch);
+    };
+    switch (event.type) {
+        case "run.started":
+            return {
+                ...run,
+                status: "running",
+                started_at: run.started_at ?? now,
+                events: [...run.events, event],
+            };
+        case "stage.started":
+            updateStage(event.stage_id, {
+                status: "running",
+                started_at: now,
+                stage_index: event.stage_index,
+                stage_total: event.stage_total,
+            });
+            break;
+        case "artifact.written": {
+            const stage = stageFor(event.stage_id);
+            updateStage(event.stage_id, {
+                artifacts: uniqueArtifacts([...(stage.artifacts ?? []), event.artifact]),
+            });
+            break;
+        }
+        case "proof.updated":
+            if (event.stage_id) {
+                updateStage(event.stage_id, {
+                    latest_proof: event.proof,
+                });
+            }
+            return {
+                ...run,
+                latest_proof: event.proof,
+                events: [...run.events, event],
+            };
+        case "log.appended":
+            break;
+        case "stage.passed":
+            updateStage(event.stage_id, {
+                status: "succeeded",
+                finished_at: now,
+                summary: event.summary ?? null,
+                failure: null,
+            });
+            break;
+        case "stage.failed":
+            updateStage(event.stage_id, {
+                status: "failed",
+                finished_at: now,
+                summary: event.error,
+                failure: event.error,
+            });
+            break;
+        case "run.completed":
+            return {
+                ...run,
+                // Once cancelled, the cancelled status is sticky; the handler may
+                // still emit a completion event after the cancel signal has landed.
+                status: run.status === "cancelled" ? "cancelled" : "succeeded",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
+        case "run.failed":
+            return {
+                ...run,
+                status: run.status === "cancelled" ? "cancelled" : "failed",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
+        case "readiness.updated":
+            return {
+                ...run,
+                readiness: event.readiness,
+                events: [...run.events, event],
+            };
+        default:
+            break;
+    }
+    return {
+        ...run,
+        events: [...run.events, event],
+    };
+}
+export function applyEventToLocalJob(run, event) {
+    const stepFor = (stepId) => {
+        const existing = run.steps.find((step) => step.id === stepId);
+        if (existing)
+            return existing;
+        const created = {
+            id: stepId,
+            label: stepId,
+            status: "queued",
+        };
+        run.steps.push(created);
+        return created;
+    };
+    const updateStep = (stepId, patch) => {
+        if (!stepId)
+            return;
+        Object.assign(stepFor(stepId), patch);
+    };
+    switch (event.type) {
+        case "job.started":
+            return {
+                ...run,
+                status: "running",
+                started_at: run.started_at ?? event.timestamp,
+                events: [...run.events, event],
+            };
+        case "step.started":
+            updateStep(event.step_id, {
+                status: "running",
+                started_at: event.timestamp,
+                ...(event.input ? { input: event.input } : {}),
+            });
+            break;
+        case "step.completed":
+            updateStep(event.step_id, {
+                status: "succeeded",
+                finished_at: event.timestamp,
+                summary: event.message ?? null,
+                ...(event.output ? { output: event.output } : {}),
+            });
+            break;
+        case "step.failed":
+            updateStep(event.step_id, {
+                status: "failed",
+                finished_at: event.timestamp,
+                summary: event.message ?? null,
+                ...(event.output ? { output: event.output } : {}),
+            });
+            break;
+        case "job.completed":
+            return {
+                ...run,
+                status: "succeeded",
+                finished_at: run.finished_at ?? event.timestamp,
+                events: [...run.events, event],
+            };
+        case "job.failed":
+            return {
+                ...run,
+                status: "failed",
+                finished_at: run.finished_at ?? event.timestamp,
+                error: event.message ?? "Job failed.",
+                events: [...run.events, event],
+            };
+        case "artifact.written":
+        case "log.appended":
+            break;
+        default:
+            break;
+    }
+    return {
+        ...run,
+        events: [...run.events, event],
+    };
+}

package/dist/packages/local-service/runtime-persistence.d.ts

@@ -0,0 +1,47 @@
+import { type CompileRun } from "../execution/lib/schema.js";
+import { type RuntimeRun } from "../compiler/lib/schema.js";
+import { type ActionProposalResource, type LocalJobRunResource, type TestRunResource } from "./lib/schema.js";
+export declare function compileRunsRoot(compiledPath: string): string;
+export declare function compileRunPath(compiledPath: string, runId: string): string;
+export declare function testRunsRoot(compiledPath: string): string;
+export declare function testRunPath(compiledPath: string, runId: string): string;
+export declare function localJobsRoot(rootPath: string): string;
+export declare function localJobPath(rootPath: string, runId: string): string;
+export declare function actionProposalsRoot(rootPath: string): string;
+export declare function actionProposalPath(rootPath: string, proposalId: string): string;
+export declare function readJsonFile(filePath: string): unknown | null;
+export declare function writeJsonFile(filePath: string, value: unknown): void;
+export declare function readJsonOrNull<T>(filePath: string, schema: {
+    safeParse(value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+    };
+}): T | null;
+export declare function listJsonFiles(dirPath: string): string[];
+export declare function readCompileRunAt(filePath: string): CompileRun | null;
+export declare function readTestRunAt(filePath: string): TestRunResource | null;
+export declare function readLocalJobRunAt(filePath: string): LocalJobRunResource | null;
+export declare function readActionProposalAt(filePath: string): ActionProposalResource | null;
+/**
+ * Read the per-stage runtime-run history NDJSON. Each line is a `RuntimeRun`
+ * record; lines that fail to parse are silently skipped so the runtime can
+ * tolerate a partially-written tail without crashing.
+ */
+export declare function readRuntimeRunHistory(compiledPath: string): RuntimeRun[];
+/**
+ * Sort items newest-first using `started_at` (with a `finished_at` fallback).
+ * Used for compile/test run lists where the canonical order is by activity
+ * window, not by record-creation time.
+ */
+export declare function newestFirst<T extends {
+    started_at?: string | null;
+    finished_at?: string | null;
+}>(items: T[]): T[];
+/** Sort items newest-first using their `created_at` timestamp. */
+export declare function byCreatedAtDesc<T extends {
+    created_at: string;
+}>(items: T[]): T[];
+/** Parse an ISO timestamp into milliseconds; returns 0 for invalid input. */
+export declare function timestampKey(value?: string | null): number;

package/dist/packages/local-service/runtime-persistence.js

@@ -0,0 +1,137 @@
+/**
+ * Filesystem and JSON persistence helpers for the local service runtime.
+ *
+ * These functions are pure: they take absolute paths and return values, with
+ * no shared state. Every other runtime module composes on top of this layer
+ * so the runtime coordinator stays small.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { CompileRunSchema, } from "../execution/lib/schema.js";
+import { compiledRuntimeRunHistoryPath, compiledRuntimeRoot, testRootForCompiled, } from "../compiler/compiled-paths.js";
+import { RuntimeRunSchema, } from "../compiler/lib/schema.js";
+import { asPreparationDataDir, preparationServiceActionProposalsRoot, preparationServiceJobsRoot, } from "../contracts/lib/preparation-paths.js";
+import { ActionProposalResourceSchema, LocalJobRunResourceSchema, TestRunResourceSchema, } from "./lib/schema.js";
+// ---- Path helpers --------------------------------------------------------
+export function compileRunsRoot(compiledPath) {
+    return join(compiledRuntimeRoot(compiledPath), "compile-runs");
+}
+export function compileRunPath(compiledPath, runId) {
+    return join(compileRunsRoot(compiledPath), `${runId}.json`);
+}
+export function testRunsRoot(compiledPath) {
+    return join(testRootForCompiled(compiledPath), "service-runs");
+}
+export function testRunPath(compiledPath, runId) {
+    return join(testRunsRoot(compiledPath), `${runId}.json`);
+}
+export function localJobsRoot(rootPath) {
+    return preparationServiceJobsRoot(asPreparationDataDir(rootPath));
+}
+export function localJobPath(rootPath, runId) {
+    return join(localJobsRoot(rootPath), `${runId}.json`);
+}
+export function actionProposalsRoot(rootPath) {
+    return preparationServiceActionProposalsRoot(asPreparationDataDir(rootPath));
+}
+export function actionProposalPath(rootPath, proposalId) {
+    return join(actionProposalsRoot(rootPath), `${proposalId}.json`);
+}
+// ---- JSON IO -------------------------------------------------------------
+export function readJsonFile(filePath) {
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeJsonFile(filePath, value) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function readJsonOrNull(filePath, schema) {
+    const raw = readJsonFile(filePath);
+    if (raw === null)
+        return null;
+    const parsed = schema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+export function listJsonFiles(dirPath) {
+    if (!existsSync(dirPath))
+        return [];
+    try {
+        if (!statSync(dirPath).isDirectory())
+            return [];
+    }
+    catch {
+        return [];
+    }
+    return readdirSync(dirPath)
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => join(dirPath, entry));
+}
+// ---- Typed readers -------------------------------------------------------
+export function readCompileRunAt(filePath) {
+    return readJsonOrNull(filePath, CompileRunSchema);
+}
+export function readTestRunAt(filePath) {
+    return readJsonOrNull(filePath, TestRunResourceSchema);
+}
+export function readLocalJobRunAt(filePath) {
+    return readJsonOrNull(filePath, LocalJobRunResourceSchema);
+}
+export function readActionProposalAt(filePath) {
+    return readJsonOrNull(filePath, ActionProposalResourceSchema);
+}
+/**
+ * Read the per-stage runtime-run history NDJSON. Each line is a `RuntimeRun`
+ * record; lines that fail to parse are silently skipped so the runtime can
+ * tolerate a partially-written tail without crashing.
+ */
+export function readRuntimeRunHistory(compiledPath) {
+    const historyPath = compiledRuntimeRunHistoryPath(compiledPath);
+    if (!existsSync(historyPath))
+        return [];
+    try {
+        return readFileSync(historyPath, "utf8")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            try {
+                return RuntimeRunSchema.safeParse(JSON.parse(line));
+            }
+            catch {
+                return { success: false };
+            }
+        })
+            .filter((parsed) => parsed.success)
+            .map((parsed) => parsed.data);
+    }
+    catch {
+        return [];
+    }
+}
+// ---- Sort helpers --------------------------------------------------------
+/**
+ * Sort items newest-first using `started_at` (with a `finished_at` fallback).
+ * Used for compile/test run lists where the canonical order is by activity
+ * window, not by record-creation time.
+ */
+export function newestFirst(items) {
+    return [...items].sort((left, right) => {
+        const leftTime = Date.parse(left.started_at ?? left.finished_at ?? "");
+        const rightTime = Date.parse(right.started_at ?? right.finished_at ?? "");
+        return (Number.isFinite(rightTime) ? rightTime : 0) - (Number.isFinite(leftTime) ? leftTime : 0);
+    });
+}
+/** Sort items newest-first using their `created_at` timestamp. */
+export function byCreatedAtDesc(items) {
+    return [...items].sort((left, right) => Date.parse(right.created_at) - Date.parse(left.created_at));
+}
+/** Parse an ISO timestamp into milliseconds; returns 0 for invalid input. */
+export function timestampKey(value) {
+    const parsed = Date.parse(value ?? "");
+    return Number.isFinite(parsed) ? parsed : 0;
+}

package/dist/packages/local-service/runtime-proposal-helpers.d.ts

@@ -0,0 +1,35 @@
+import { type SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type ActionProposalPlanActionType, type ActionProposalResource } from "./lib/schema.js";
+export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+export type LocalTestMode = "source-files" | "compiled" | "both";
+export declare function createActionProposalId(): string;
+export declare function sanitizeActionProposalPlan(value: unknown): unknown;
+export declare function configuredAgentName(): string | null;
+export declare function detectedExecutorOptions(currentAgentName: string | null): {
+    name: string;
+    display_name: string;
+    command: string;
+    current: boolean;
+}[];
+export declare function slugFromText(value: string): string;
+export declare function escapeRegExp(value: string): string;
+export declare function stringValue(values: Record<string, unknown> | undefined, key: string): string | null;
+export declare function actionTypeFromValues(values: Record<string, unknown> | undefined): ActionProposalPlanActionType | null;
+export declare function directServiceEndpointForAction(actionType: ActionProposalPlanActionType): string | null;
+export declare function numberValue(values: Record<string, unknown> | undefined, key: string): number | null;
+export declare function testModeFromValues(values: Record<string, unknown> | undefined): LocalTestMode | null;
+export declare function testModeValue(values: Record<string, unknown> | undefined, defaultMode?: LocalTestMode): LocalTestMode;
+export declare function testModeCliTarget(mode: LocalTestMode): "source-files" | "portable-context" | "both";
+export declare function methodIdForProposal(message: string, values: Record<string, unknown> | undefined): string;
+export declare function actionValueMethodTaskPrompt(values: Record<string, unknown> | undefined): string | null;
+export declare function normalizeMethodAuthoringText(value: string): string;
+export declare function extractMethodAuthoringSection(value: string, label: string): string | null;
+export declare function stripMethodCommandPrefix(value: string, methodId: string): string;
+export declare function methodAuthoringPromptFallback(message: string, methodId: string): string;
+export declare function methodAuthoringHintFromPrompt(prompt: string): string;
+export declare function methodLabelFromId(methodId: string): string;
+export declare function detachMethodFromPreparation(preparation: SourcePreparationConfig, methodId: string): SourcePreparationConfig;
+export declare function requireSelectedMethod(preparation: SourcePreparationConfig): string;
+export declare function actionCommandPreview(actionType: ActionProposalResource["action_type"], preparationName: string | null, methodId: string | null, values: Record<string, unknown> | undefined): string;
+export declare function hasCompiledTestTarget(sourcePath: string, preparationConfig: SourcePreparationConfig): boolean;
+export declare function actionAssistantMessage(actionType: ActionProposalResource["action_type"], preparationName: string | null, commandPreview: string): string;

package/dist/packages/local-service/runtime-proposal-helpers.js

@@ -0,0 +1,251 @@
+/**
+ * Pure helpers used by the runtime's action-proposal and method-authoring
+ * paths. None of these depend on runtime state — they shape strings, parse
+ * proposal values, and build CLI previews. Keeping them out of runtime.ts
+ * lets the coordinator stay small and means future tests can reach these
+ * helpers without booting a runtime.
+ */
+import { existsSync } from "node:fs";
+import { AGENTS, } from "../agents/lib/constants.js";
+import { detectAgents, supportsAutomatedRuns, } from "../agents/lib/detection.js";
+import { loadUserConfig, } from "../agents/lib/user-config.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
+import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../project-model/source-config.js";
+import { createCompiledTestTarget, } from "../testing/test-targets.js";
+import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, } from "./action-values.js";
+import { ActionProposalPlanActionTypeSchema, } from "./lib/schema.js";
+export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+export function createActionProposalId() {
+    return `action_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function sanitizeActionProposalPlan(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const plan = { ...value };
+    for (const key of ["preparation", "method", "title", "summary", "assistant_message", "command_preview"]) {
+        const current = plan[key];
+        if (current === null || current === undefined) {
+            delete plan[key];
+            continue;
+        }
+        if (typeof current === "string" && current.trim().length === 0) {
+            delete plan[key];
+        }
+    }
+    return plan;
+}
+export function configuredAgentName() {
+    const config = loadUserConfig();
+    if (!config)
+        return null;
+    const configured = AGENTS.find((agent) => agent.command === config.agentCommand) ??
+        AGENTS.find((agent) => agent.name === config.agent) ??
+        AGENTS.find((agent) => agent.displayName === config.agent);
+    return configured?.name ?? null;
+}
+export function detectedExecutorOptions(currentAgentName) {
+    return detectAgents()
+        .filter(supportsAutomatedRuns)
+        .map((agent) => ({
+        name: agent.name,
+        display_name: agent.displayName,
+        command: agent.command,
+        current: agent.name === currentAgentName,
+    }));
+}
+export function slugFromText(value) {
+    const slug = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 42)
+        .replace(/-+$/g, "");
+    return slug || "custom";
+}
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function stringValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+export function actionTypeFromValues(values) {
+    const explicit = stringValue(values, "action_type") ?? stringValue(values, "service_action");
+    if (explicit) {
+        const parsed = ActionProposalPlanActionTypeSchema.safeParse(explicit);
+        if (parsed.success && parsed.data !== "clarification")
+            return parsed.data;
+    }
+    const action = stringValue(values, "action");
+    if (action === "compile" || action === "compile-run" || action === "run-preparation")
+        return "compile";
+    if (action === "test" || action === "check-readiness")
+        return "test";
+    if (action === "draft-readiness-checks" || action === "readiness-check-draft")
+        return "readiness-check-draft";
+    if (action === "create-method" || action === "method-authoring")
+        return "method-authoring";
+    if (action === "method-duplicate" || action === "method-remove" || action === "method-change")
+        return "method-change";
+    if (action === "preparation-remove" || action === "preparation-change")
+        return "preparation-change";
+    if (action === "improve-preparation" || action === "method-improvement")
+        return "method-improvement";
+    return null;
+}
+export function directServiceEndpointForAction(actionType) {
+    if (actionType === "preparation-setup")
+        return "/v1/preparation-setups";
+    if (actionType === "method-change")
+        return "/v1/method-changes";
+    if (actionType === "preparation-change")
+        return "/v1/preparation-changes";
+    return null;
+}
+export function numberValue(values, key) {
+    const value = values?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+export function testModeFromValues(values) {
+    const value = stringValue(values, "mode") ?? stringValue(values, "target");
+    if (value === "portable-context")
+        return "compiled";
+    return value === "source-files" || value === "compiled" || value === "both" ? value : null;
+}
+export function testModeValue(values, defaultMode = "both") {
+    return testModeFromValues(values) ?? defaultMode;
+}
+export function testModeCliTarget(mode) {
+    if (mode === "source-files")
+        return "source-files";
+    if (mode === "compiled")
+        return "portable-context";
+    return "both";
+}
+export function methodIdForProposal(message, values) {
+    const explicit = stringValue(values, "method_id") ??
+        stringValue(values, "method");
+    const fromMessage = message.match(/\b(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\s+([a-z0-9][a-z0-9-]{0,79})\b/i)?.[1];
+    return explicit ?? fromMessage ?? `custom-${slugFromText(message)}`;
+}
+export function actionValueMethodTaskPrompt(values) {
+    const parsed = MethodAuthoringActionValuesSchema.safeParse(values);
+    return parsed.success ? methodAuthoringTaskPrompt(parsed.data) : null;
+}
+const METHOD_AUTHORING_INTERNAL_INSTRUCTION = /Use the attached values as the Method authoring request before proposing the action\.?/gi;
+const METHOD_AUTHORING_LABELS = [
+    "Agent work",
+    "Portable-context output",
+    "Readiness checks",
+    "CLI preview",
+];
+export function normalizeMethodAuthoringText(value) {
+    return value
+        .replace(/[│]+/g, " ")
+        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function extractMethodAuthoringSection(value, label) {
+    const otherLabels = METHOD_AUTHORING_LABELS
+        .filter((candidate) => candidate !== label)
+        .map(escapeRegExp)
+        .join("|");
+    const match = value.match(new RegExp(`${escapeRegExp(label)}\\s*:\\s*([\\s\\S]*?)(?=\\s*(?:${otherLabels})\\s*:|$)`, "i"));
+    return match?.[1] ? normalizeMethodAuthoringText(match[1]) : null;
+}
+export function stripMethodCommandPrefix(value, methodId) {
+    const specific = new RegExp(`^(?:create|reate|eate|draft|author|build|make)\\s+(?:a\\s+new\\s+)?(?:interf\\s+)?method\\s+${escapeRegExp(methodId)}\\.?\\s*`, "i");
+    const generic = /^(?:create|reate|eate|draft|author|build|make)\s+(?:a\s+new\s+)?(?:interf\s+)?method\b[^.]{0,180}\.\s*/i;
+    const stripped = normalizeMethodAuthoringText(value)
+        .replace(specific, "")
+        .replace(generic, "")
+        .trim();
+    return stripped || normalizeMethodAuthoringText(value);
+}
+export function methodAuthoringPromptFallback(message, methodId) {
+    const cleaned = message
+        .replace(/[│]+/g, " ")
+        .replace(METHOD_AUTHORING_INTERNAL_INSTRUCTION, " ")
+        .trim();
+    const agentWork = extractMethodAuthoringSection(cleaned, "Agent work");
+    const portableOutput = extractMethodAuthoringSection(cleaned, "Portable-context output");
+    const readinessNotes = extractMethodAuthoringSection(cleaned, "Readiness checks");
+    const lines = [
+        agentWork ? `Agent work: ${stripMethodCommandPrefix(agentWork, methodId)}` : null,
+        portableOutput ? `Portable-context output: ${portableOutput}` : null,
+        readinessNotes ? `Readiness checks: ${readinessNotes}` : null,
+    ].filter((line) => Boolean(line));
+    if (lines.length > 0)
+        return lines.join("\n");
+    return stripMethodCommandPrefix(cleaned, methodId);
+}
+export function methodAuthoringHintFromPrompt(prompt) {
+    const plain = normalizeMethodAuthoringText(prompt.replace(/\b(?:Agent work|Portable-context output|Readiness checks)\s*:/gi, " "));
+    if (plain.length <= 180)
+        return plain || "Custom Method";
+    const clipped = plain.slice(0, 177).replace(/\s+\S*$/, "").trim();
+    return `${clipped || plain.slice(0, 177)}...`;
+}
+export function methodLabelFromId(methodId) {
+    return methodId
+        .split("-")
+        .filter(Boolean)
+        .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join(" ") || methodId;
+}
+export function detachMethodFromPreparation(preparation, methodId) {
+    if (methodIdForSourcePreparationConfig(preparation) !== methodId)
+        return preparation;
+    const { method: _removedMethod, ...detachedPreparation } = preparation;
+    return detachedPreparation;
+}
+export function requireSelectedMethod(preparation) {
+    const methodId = methodIdForSourcePreparationConfig(preparation);
+    if (methodId)
+        return methodId;
+    throw new Error(`Select a Method for Preparation "${preparation.name}" before preparing it.`);
+}
+export function actionCommandPreview(actionType, preparationName, methodId, values) {
+    if (actionType === "compile") {
+        const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
+        return preparationName
+            ? `interf compile --preparation ${preparationName}${methodSuffix}`
+            : `interf compile${methodSuffix}`;
+    }
+    if (actionType === "test") {
+        const mode = testModeCliTarget(testModeValue(values));
+        return preparationName
+            ? `interf test --preparation ${preparationName} --target ${mode}`
+            : `interf test --target ${mode}`;
+    }
+    if (actionType === "readiness-check-draft") {
+        return "interf # choose Auto-create readiness checks";
+    }
+    if (actionType === "method-authoring" || actionType === "method-improvement") {
+        return "interf create method";
+    }
+    return "Try: create a Preparation, prepare, check readiness, draft readiness checks, or draft a Method.";
+}
+export function hasCompiledTestTarget(sourcePath, preparationConfig) {
+    const compiledPath = preparationPortableContextPath(asPreparationDataDir(sourcePath), preparationConfig.name);
+    if (!existsSync(compiledPath))
+        return false;
+    return createCompiledTestTarget(compiledPath, preparationConfig.name, methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID).eligible;
+}
+export function actionAssistantMessage(actionType, preparationName, commandPreview) {
+    const preparationSuffix = preparationName ? ` for Preparation "${preparationName}"` : "";
+    if (actionType === "compile") {
+        return `Interf prepared a compile-run proposal${preparationSuffix}. Approve to submit it through the local Interf service and watch the run in Interf. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "test") {
+        return `Interf prepared a readiness-check proposal${preparationSuffix}. Approve to run the requested target against saved readiness checks. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "readiness-check-draft") {
+        return `Interf prepared a proposal to draft readiness checks${preparationSuffix}. Approve to ask the configured local executor to draft saved checks as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    if (actionType === "method-authoring" || actionType === "method-improvement") {
+        return `Interf prepared a Method draft proposal${preparationSuffix}. Approve to draft a reusable local Method as a visible run. CLI equivalent: ${commandPreview}`;
+    }
+    return "I could not map that to a safe Interf action. Ask for one action in plain English, such as create a Preparation, prepare the data, check readiness, draft readiness checks, or draft a Method.";
+}