@interf/compiler 0.9.3 → 0.9.5

package/dist/packages/local-service/server.js

@@ -3,10 +3,10 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { LocalServiceConfigSchema, LocalServiceDiscoverySchema, LocalServiceInstancePointerSchema, OpenPathRequestSchema, RunCreateRequestSchema, } from "./lib/schema.js";
+import { LocalServiceConfigSchema, LocalServiceDiscoverySchema, LocalServiceErrorSchema, LocalServicePointerSchema, OpenPathRequestSchema, PreparationSetupCreateRequestSchema, } from "./lib/schema.js";
 import { assertPathWithinRoot, } from "../shared/path-guards.js";
 import { createLocalServiceRuntime, } from "./runtime.js";
-import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_INSTANCE_POINTER_PATH, LOCAL_SERVICE_ROUTES, } from "./routes.js";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, LOCAL_SERVICE_POINTER_PATH, LOCAL_SERVICE_ROUTES, } from "./routes.js";
 function packageRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
 }
@@ -25,21 +25,21 @@ function compilerUiStaticRoot() {
         return resolve(explicit);
     return resolveCompilerUiStaticRoot();
 }
-function localInstancePointerPath(rootPath) {
-    return join(rootPath, ...LOCAL_SERVICE_INSTANCE_POINTER_PATH);
+function localServicePointerPath(rootPath) {
+    return join(rootPath, ...LOCAL_SERVICE_POINTER_PATH);
 }
-function writeLocalInstancePointer(rootPath, pointer) {
-    const pointerPath = localInstancePointerPath(rootPath);
+function writeLocalServicePointer(rootPath, pointer) {
+    const pointerPath = localServicePointerPath(rootPath);
     mkdirSync(dirname(pointerPath), { recursive: true });
-    const parsed = LocalServiceInstancePointerSchema.parse(pointer);
+    const parsed = LocalServicePointerSchema.parse(pointer);
     writeFileSync(pointerPath, `${JSON.stringify(parsed, null, 2)}\n`);
 }
-function removeLocalInstancePointer(rootPath, serviceUrl) {
-    const pointerPath = localInstancePointerPath(rootPath);
+function removeLocalServicePointer(rootPath, serviceUrl) {
+    const pointerPath = localServicePointerPath(rootPath);
     if (!existsSync(pointerPath))
         return;
     try {
-        const pointer = LocalServiceInstancePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
+        const pointer = LocalServicePointerSchema.parse(JSON.parse(readFileSync(pointerPath, "utf8")));
         if (pointer.service_url !== serviceUrl || pointer.pid !== process.pid)
             return;
         rmSync(pointerPath, { force: true });
@@ -97,11 +97,11 @@ function sendText(res, statusCode, value) {
     res.end(value);
 }
 function sendError(res, statusCode, message) {
-    sendJson(res, statusCode, {
+    sendJson(res, statusCode, LocalServiceErrorSchema.parse({
         error: {
             message,
         },
-    });
+    }));
 }
 function resolveOpenPath(allowedRoots, pathValue) {
     const roots = allowedRoots.map((root) => resolve(root));
@@ -233,6 +233,15 @@ async function routeApi(req, res, runtime) {
                 source_files: LOCAL_SERVICE_ROUTES.sourceFiles,
                 workspace_files: LOCAL_SERVICE_ROUTES.workspaceFiles,
                 action_proposals: LOCAL_SERVICE_ROUTES.actionProposals,
+                preparation_setups: LOCAL_SERVICE_ROUTES.preparationSetups,
+                preparation_changes: LOCAL_SERVICE_ROUTES.preparationChanges,
+                method_changes: LOCAL_SERVICE_ROUTES.methodChanges,
+                readiness_check_drafts: LOCAL_SERVICE_ROUTES.readinessCheckDrafts,
+                method_authoring_runs: LOCAL_SERVICE_ROUTES.methodAuthoringRuns,
+                method_improvement_runs: LOCAL_SERVICE_ROUTES.methodImprovementRuns,
+                compile_runs: LOCAL_SERVICE_ROUTES.compileRuns,
+                test_runs: LOCAL_SERVICE_ROUTES.testRuns,
+                reset: LOCAL_SERVICE_ROUTES.reset,
                 executor: LOCAL_SERVICE_ROUTES.executor,
             },
         }));
@@ -242,6 +251,52 @@ async function routeApi(req, res, runtime) {
         sendJson(res, 200, { preparations: runtime.listPreparations() });
         return true;
     }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.preparationSetups) {
+        try {
+            const body = await readJsonBody(req);
+            const request = PreparationSetupCreateRequestSchema.parse(body);
+            const result = runtime.applyPreparationSetup(request);
+            if (request.prepare_after_setup) {
+                const resource = await runtime.createCompileRun({
+                    preparation: result.preparation,
+                    method: result.method,
+                });
+                sendJson(res, 202, {
+                    ...result,
+                    submitted_run_id: resource.run.run_id,
+                    submitted_run_type: "compile-run",
+                    message: `${result.message} Prepare run started.`,
+                });
+            }
+            else {
+                sendJson(res, 202, result);
+            }
+        }
+        catch (error) {
+            sendError(res, 409, error instanceof Error ? error.message : String(error));
+        }
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.reset) {
+        try {
+            const body = await readJsonBody(req);
+            sendJson(res, 202, runtime.applyReset(body));
+        }
+        catch (error) {
+            sendError(res, 409, error instanceof Error ? error.message : String(error));
+        }
+        return true;
+    }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.preparationChanges) {
+        try {
+            const body = await readJsonBody(req);
+            sendJson(res, 202, runtime.applyPreparationChange(body));
+        }
+        catch (error) {
+            sendError(res, 409, error instanceof Error ? error.message : String(error));
+        }
+        return true;
+    }
     if (method === "GET" && path === LOCAL_SERVICE_ROUTES.workspaceFiles) {
         sendJson(res, 200, { workspace_files: runtime.listWorkspaceFiles() });
         return true;
@@ -288,6 +343,16 @@ async function routeApi(req, res, runtime) {
         sendJson(res, 200, { methods: runtime.listMethods() });
         return true;
     }
+    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.methodChanges) {
+        try {
+            const body = await readJsonBody(req);
+            sendJson(res, 202, runtime.applyMethodChange(body));
+        }
+        catch (error) {
+            sendError(res, 409, error instanceof Error ? error.message : String(error));
+        }
+        return true;
+    }
     const methodMatch = path.match(/^\/v1\/methods\/([^/]+)$/);
     if (method === "GET" && methodMatch?.[1]) {
         const methodResource = runtime.getMethod(decodeURIComponent(methodMatch[1]));
@@ -345,19 +410,6 @@ async function routeApi(req, res, runtime) {
         sendJson(res, 200, { runs: runtime.listRunObservability() });
         return true;
     }
-    if (method === "POST" && path === LOCAL_SERVICE_ROUTES.runs) {
-        const request = RunCreateRequestSchema.parse(await readJsonBody(req));
-        if (request.run_type === "compile" || request.run_type === "prepare") {
-            const { run_type: _ignoredRunType, ...compileRequest } = request;
-            const resource = await runtime.createCompileRun(compileRequest);
-            sendJson(res, 202, runtime.getRunObservability(resource.run.run_id) ?? resource);
-            return true;
-        }
-        const { run_type: _ignoredRunType, ...testRequest } = request;
-        const resource = await runtime.createTestRun(testRequest);
-        sendJson(res, 202, runtime.getRunObservability(resource.run_id) ?? resource);
-        return true;
-    }
     const observableRunMatch = path.match(/^\/v1\/runs\/([^/]+)$/);
     if (method === "GET" && observableRunMatch?.[1]) {
         const run = runtime.getRunObservability(decodeURIComponent(observableRunMatch[1]));
@@ -367,11 +419,6 @@ async function routeApi(req, res, runtime) {
             sendJson(res, 200, run);
         return true;
     }
-    if (method === "POST" && path === "/v1/jobs") {
-        const body = await readJsonBody(req);
-        sendJson(res, 202, runtime.createJobRun(body));
-        return true;
-    }
     const jobMatch = path.match(/^\/v1\/jobs\/([^/]+)(?:\/([^/]+))?$/);
     if (jobMatch?.[1]) {
         const runId = decodeURIComponent(jobMatch[1]);
@@ -392,15 +439,6 @@ async function routeApi(req, res, runtime) {
                 sendJson(res, 200, { events });
             return true;
         }
-        if (method === "POST" && child === "events") {
-            const body = await readJsonBody(req);
-            const job = runtime.appendJobRunEvent(runId, body);
-            if (!job)
-                sendError(res, 404, "Job run not found.");
-            else
-                sendJson(res, 202, job);
-            return true;
-        }
     }
     if (method === "POST" && path === "/v1/readiness-check-drafts") {
         const body = await readJsonBody(req);
@@ -415,14 +453,26 @@ async function routeApi(req, res, runtime) {
         sendJson(res, 202, job);
         return true;
     }
+    if (method === "POST" &&
+        path === LOCAL_SERVICE_ROUTES.methodImprovementRuns) {
+        const body = await readJsonBody(req);
+        const job = await runtime.createMethodAuthoringRun(body, "method-improvement");
+        sendJson(res, 202, job);
+        return true;
+    }
     if (method === "GET" && path === "/v1/compile-runs") {
         sendJson(res, 200, { compile_runs: runtime.listCompileRuns() });
         return true;
     }
     if (method === "POST" && path === "/v1/compile-runs") {
-        const body = await readJsonBody(req);
-        const resource = await runtime.createCompileRun(body);
-        sendJson(res, 202, resource);
+        try {
+            const body = await readJsonBody(req);
+            const resource = await runtime.createCompileRun(body);
+            sendJson(res, 202, resource);
+        }
+        catch (error) {
+            sendError(res, 409, error instanceof Error ? error.message : String(error));
+        }
         return true;
     }
     const compileRunMatch = path.match(/^\/v1\/compile-runs\/([^/]+)(?:\/([^/]+))?$/);
@@ -551,7 +601,7 @@ export async function startLocalService(options = {}) {
         server.listen(config.port, config.host);
     });
     const url = runtime.health().service_url;
-    writeLocalInstancePointer(rootPath, {
+    writeLocalServicePointer(rootPath, {
         service_url: url,
         host: config.host,
         port: config.port,
@@ -569,7 +619,7 @@ export async function startLocalService(options = {}) {
                     rejectClose(error);
                     return;
                 }
-                removeLocalInstancePointer(rootPath, url);
+                removeLocalServicePointer(rootPath, url);
                 resolveClose();
             });
         }),

package/dist/packages/method-package/method-review-paths.d.ts

@@ -1,7 +1,7 @@
 import type { MethodImprovementContext } from "../compiler/lib/schema.js";
 export interface MethodImprovementReviewSourcePaths {
     compiledRuntime: string | null;
-    testComparisons: string | null;
+    readinessRuns: string | null;
     executionShells: string | null;
     targetTestRuns: string | null;
     targetTestSandboxes: string | null;

package/dist/packages/method-package/method-review-paths.js

@@ -3,15 +3,15 @@ import { join } from "node:path";
 import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../compiler/compiled-paths.js";
 export function resolveMethodImprovementReviewSourcePaths(compiledPath) {
     const compiledRuntime = compiledRuntimeRoot(compiledPath);
-    const testComparisons = testRootForCompiled(compiledPath);
+    const readinessRuns = testRootForCompiled(compiledPath);
     const executionShells = stageExecutionShellsRoot(compiledPath);
     const targetTestRuns = targetTestRunsRootForCompiled(compiledPath);
     const targetTestSandboxes = targetTestSandboxesRootForCompiled(compiledPath);
     return {
         compiledRuntime: existsSync(compiledRuntime) ? compiledRuntime : null,
-        testComparisons: existsSync(join(testComparisons, "latest.json")) ||
-            existsSync(join(testComparisons, "latest.md"))
-            ? testComparisons
+        readinessRuns: existsSync(join(readinessRuns, "latest.json")) ||
+            existsSync(join(readinessRuns, "latest.md"))
+            ? readinessRuns
             : null,
         executionShells: existsSync(executionShells) ? executionShells : null,
         targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
@@ -23,7 +23,7 @@ export function resolveMethodImprovementReviewPaths(compiledPath) {
     return {
         method_root: "method",
         compiled_runtime: sources.compiledRuntime ? "artifacts/compiled-runtime" : null,
-        test_comparisons: sources.testComparisons ? "artifacts/test-comparisons" : null,
+        readiness_runs: sources.readinessRuns ? "artifacts/readiness-runs" : null,
         execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,
         test_runs: sources.targetTestRuns ? "artifacts/test-runs" : null,
         test_sandboxes: sources.targetTestSandboxes ? "artifacts/test-sandboxes" : null,

package/dist/packages/project-model/index.d.ts

@@ -6,4 +6,5 @@ export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
 export * as projectPaths from "./project-paths.js";
+export * as preparationEntries from "./preparation-entries.js";
 export type { InterfConfig, MethodId, PreparationName, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";

package/dist/packages/project-model/index.js

@@ -6,3 +6,4 @@ export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
 export * as projectPaths from "./project-paths.js";
+export * as preparationEntries from "./preparation-entries.js";

package/dist/packages/project-model/preparation-entries.d.ts

@@ -0,0 +1,11 @@
+import type { SourcePreparationConfig } from "./lib/schema.js";
+export interface SavedPreparationEntry {
+    config: SourcePreparationConfig;
+    path: string | null;
+    localDraft: boolean;
+}
+export declare function listSavedPreparationEntries(sourcePath: string): SavedPreparationEntry[];
+export declare function findBuiltPortableContextPath(sourcePath: string, preparationName: string): string | null;
+export declare function findSavedPreparationConfig(sourcePath: string, preparationName: string): SourcePreparationConfig | null;
+export declare function createPortableContextFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;
+export declare function ensurePortableContextFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;

package/dist/packages/project-model/preparation-entries.js

@@ -0,0 +1,49 @@
+import { listPortableContextsForSourceFolder, } from "./interf-detect.js";
+import { createCompiled, ensurePortableContextScaffold, } from "./interf-scaffold.js";
+import { listSourcePreparationConfigs, loadCompiledPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncCompiledInterfConfigFromSourcePreparationConfig, } from "./source-config.js";
+import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
+export function listSavedPreparationEntries(sourcePath) {
+    const builtEntries = new Map();
+    for (const builtContext of listPortableContextsForSourceFolder(sourcePath)) {
+        const preparationConfig = loadCompiledPreparationConfig(builtContext.path)
+            ?? sourcePreparationConfigFromInterfConfig(builtContext.config);
+        builtEntries.set(builtContext.config.name, {
+            config: preparationConfig,
+            path: builtContext.path,
+            localDraft: builtContext.config.method_origin?.local_draft === true,
+        });
+    }
+    const entries = new Map();
+    for (const config of listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath))) {
+        const built = builtEntries.get(config.name);
+        entries.set(config.name, {
+            config,
+            path: built?.path ?? null,
+            localDraft: built?.localDraft ?? false,
+        });
+    }
+    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
+}
+export function findBuiltPortableContextPath(sourcePath, preparationName) {
+    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === preparationName)?.path ?? null;
+}
+export function findSavedPreparationConfig(sourcePath, preparationName) {
+    return listSavedPreparationEntries(sourcePath).find((entry) => entry.config.name === preparationName)?.config ?? null;
+}
+export function createPortableContextFromConfig(sourcePath, preparationConfig) {
+    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+    const sourceFolderPath = resolveSourcePreparationPath(sourcePath, preparationConfig);
+    const compiledPath = createCompiled(preparationConfig.name, sourcePath, methodId, preparationConfig.about, sourceFolderPath);
+    syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
+    return compiledPath;
+}
+export function ensurePortableContextFromConfig(sourcePath, preparationConfig) {
+    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+    const existingPath = findBuiltPortableContextPath(sourcePath, preparationConfig.name);
+    if (existingPath) {
+        ensurePortableContextScaffold(sourcePath, preparationConfig.name, methodId);
+        syncCompiledInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
+        return existingPath;
+    }
+    return createPortableContextFromConfig(sourcePath, preparationConfig);
+}

package/dist/packages/project-model/source-config.d.ts

@@ -27,6 +27,7 @@ export declare function appendSourcePreparationChecks(sourcePath: string, prepar
 export declare function upsertSourcePreparationConfig(sourcePath: string, preparationConfig: SourcePreparationConfig, options?: {
     matchName?: string;
 }): void;
+export declare function removeSourcePreparationConfig(sourcePath: string, preparationName: string): boolean;
 export declare function compiledMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
 export declare function compiledMaxLoops(maxLoops: number | null | undefined): number | undefined;
 export declare function sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;

package/dist/packages/project-model/source-config.js

@@ -124,7 +124,7 @@ function toWritableSourcePreparationConfig(preparation) {
         name: preparation.name,
         path: preparation.path,
         ...(preparation.about ? { about: preparation.about } : {}),
-        method: method ?? DEFAULT_METHOD_ID,
+        ...(method ? { method } : {}),
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
@@ -174,6 +174,17 @@ export function upsertSourcePreparationConfig(sourcePath, preparationConfig, opt
         preparations,
     });
 }
+export function removeSourcePreparationConfig(sourcePath, preparationName) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const preparations = listSourcePreparationConfigs(existing);
+    const nextPreparations = preparations.filter((entry) => entry.name !== preparationName);
+    if (nextPreparations.length === preparations.length)
+        return false;
+    saveSourceFolderConfig(sourcePath, {
+        preparations: nextPreparations,
+    });
+    return true;
+}
 export function compiledMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;

package/dist/packages/testing/lib/schema.d.ts

@@ -244,9 +244,8 @@ export declare const ReadinessCheckRunSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
-        raw_pass_rate: z.ZodNullable<z.ZodNumber>;
-        compiled_pass_rate: z.ZodNullable<z.ZodNumber>;
-        pass_rate_delta: z.ZodNullable<z.ZodNumber>;
+        source_files_pass_rate: z.ZodNullable<z.ZodNumber>;
+        portable_context_pass_rate: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type { TestCaseExpect, TestTargetType };

package/dist/packages/testing/lib/schema.js

@@ -111,8 +111,7 @@ export const ReadinessCheckRunSchema = z.object({
     raw: TestRunTargetSummarySchema.nullable(),
     compiled: TestRunTargetSummarySchema.nullable(),
     summary: z.object({
-        raw_pass_rate: z.number().nullable(),
-        compiled_pass_rate: z.number().nullable(),
-        pass_rate_delta: z.number().nullable(),
+        source_files_pass_rate: z.number().nullable(),
+        portable_context_pass_rate: z.number().nullable(),
     }),
 });

package/dist/packages/testing/readiness-check-run.d.ts

@@ -16,8 +16,8 @@ export interface ReadinessCheckRunResult {
     mode: TestRunMode;
     rawOutcome: SavedReadinessCheckOutcome | null;
     compiledOutcome: SavedReadinessCheckOutcome | null;
-    comparisonRunPath: string | null;
-    comparison: ReadinessCheckRun | null;
+    readinessRunPath: string | null;
+    readinessRun: ReadinessCheckRun | null;
 }
 export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
 export declare function readSavedReadinessCheckRun(projectPath: string, preparationName: string): ReadinessCheckRun | null;
@@ -28,7 +28,7 @@ export declare function readCurrentSavedReadinessCheckRun(options: {
     preparationName: string;
     checks: SourcePreparationConfig["checks"];
 }): {
-    comparison: ReadinessCheckRun | null;
+    readinessRun: ReadinessCheckRun | null;
     stale: boolean;
 };
 export declare function saveReadinessCheckRun(options: {

package/dist/packages/testing/readiness-check-run.js

@@ -48,10 +48,6 @@ function renderLatestSummaryMarkdown(payload) {
         lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
     }
     lines.push("");
-    if (payload.summary.raw_pass_rate != null && payload.summary.compiled_pass_rate != null) {
-        const direction = (payload.summary.pass_rate_delta ?? 0) >= 0 ? "improved" : "decreased";
-        lines.push(`Readiness-check pass rate ${direction} from ${payload.summary.raw_pass_rate}% to ${payload.summary.compiled_pass_rate}%.`, "");
-    }
     if (payload.raw) {
         lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
     }
@@ -74,15 +70,15 @@ export function readReadinessCheckRunAtPath(filePath, label = "readiness-check r
     return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
 }
 export function readCurrentSavedReadinessCheckRun(options) {
-    const latestComparison = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
-    if (!latestComparison) {
-        return { comparison: null, stale: false };
+    const latestRun = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
+    if (!latestRun) {
+        return { readinessRun: null, stale: false };
     }
     const currentFingerprint = fingerprintReadinessChecks(options.checks);
-    if (!latestComparison.checks_fingerprint || latestComparison.checks_fingerprint !== currentFingerprint) {
-        return { comparison: null, stale: true };
+    if (!latestRun.checks_fingerprint || latestRun.checks_fingerprint !== currentFingerprint) {
+        return { readinessRun: null, stale: true };
     }
-    return { comparison: latestComparison, stale: false };
+    return { readinessRun: latestRun, stale: false };
 }
 export function saveReadinessCheckRun(options) {
     const generatedAt = new Date().toISOString();
@@ -117,9 +113,8 @@ export function saveReadinessCheckRun(options) {
         raw: rawSummary,
         compiled: compiledSummary,
         summary: {
-            raw_pass_rate: rawPassRate,
-            compiled_pass_rate: compiledPassRate,
-            pass_rate_delta: rawPassRate !== null && compiledPassRate !== null ? compiledPassRate - rawPassRate : null,
+            source_files_pass_rate: rawPassRate,
+            portable_context_pass_rate: compiledPassRate,
         },
     };
     const latestStatePath = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
@@ -228,7 +223,7 @@ export async function runReadinessChecksForExecutor(options) {
         (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
         (options.mode !== "both" || (Boolean(rawOutcome) && Boolean(compiledOutcome)));
     const shouldSave = options.saveLatest !== false;
-    const comparisonRunPath = shouldSave && modeSatisfied
+    const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
             sourcePath: options.sourcePath,
             portableContextPath: options.portableContextPath,
@@ -239,7 +234,7 @@ export async function runReadinessChecksForExecutor(options) {
             compiledOutcome,
         })
         : null;
-    const comparison = shouldSave && modeSatisfied
+    const readinessRun = shouldSave && modeSatisfied
         ? readSavedReadinessCheckRun(options.sourcePath, options.preparationConfig.name)
         : null;
     return {
@@ -249,8 +244,8 @@ export async function runReadinessChecksForExecutor(options) {
         mode: options.mode,
         rawOutcome,
         compiledOutcome,
-        comparisonRunPath,
-        comparison,
+        readinessRunPath,
+        readinessRun,
     };
 }
 function portableContextPathForPreparation(sourcePath, preparationName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
@@ -14,17 +14,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./compiler": {
-      "types": "./dist/packages/compiler/index.d.ts",
-      "import": "./dist/packages/compiler/index.js"
-    },
-    "./method-package": {
-      "types": "./dist/packages/method-package/index.d.ts",
-      "import": "./dist/packages/method-package/index.js"
-    },
-    "./method-authoring": {
-      "types": "./dist/packages/method-authoring/index.d.ts",
-      "import": "./dist/packages/method-authoring/index.js"
+    "./contracts": {
+      "types": "./dist/packages/contracts/index.d.ts",
+      "import": "./dist/packages/contracts/index.js"
     },
     "./execution": {
       "types": "./dist/packages/execution/index.d.ts",
@@ -34,18 +26,6 @@
       "types": "./dist/packages/local-service/index.d.ts",
       "import": "./dist/packages/local-service/index.js"
     },
-    "./project-model": {
-      "types": "./dist/packages/project-model/index.d.ts",
-      "import": "./dist/packages/project-model/index.js"
-    },
-    "./agents": {
-      "types": "./dist/packages/agents/index.d.ts",
-      "import": "./dist/packages/agents/index.js"
-    },
-    "./testing": {
-      "types": "./dist/packages/testing/index.d.ts",
-      "import": "./dist/packages/testing/index.js"
-    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -74,6 +54,7 @@
     "dist",
     "builtin-methods",
     "agent-skills",
+    "CHANGELOG.md",
     "TRADEMARKS.md"
   ],
   "publishConfig": {

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

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

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

@@ -1,25 +0,0 @@
-import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
-import { type StageShellRetentionMode, type CompiledCompileResult } from "../../packages/compiler/method-runs.js";
-import type { MethodExecutor } from "../../packages/agents/lib/executors.js";
-import type { RunEventSink } from "../../packages/execution/events.js";
-export interface SavedPreparationEntry {
-    config: SourcePreparationConfig;
-    path: string | null;
-    localDraft: boolean;
-}
-export declare function listSavedPreparationEntries(sourcePath: string): SavedPreparationEntry[];
-export declare function findBuiltCompiledPath(sourcePath: string, compiledName: string): string | null;
-export declare function findSavedCompiledConfig(sourcePath: string, compiledName: string): SourcePreparationConfig | null;
-export declare function chooseCompiledConfigToBuild(options: {
-    sourcePath: string;
-    selectMessage: string;
-}): Promise<SourcePreparationConfig | null | undefined>;
-export declare function createCompiledFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;
-export declare function ensureCompiledFromConfig(sourcePath: string, preparationConfig: SourcePreparationConfig): string;
-export declare function compileCompiledWithReporter(executor: MethodExecutor, compiledPath: string, options?: {
-    heading?: string;
-    successMessage?: string;
-    preserveStageShells?: StageShellRetentionMode;
-    runId?: string;
-    events?: RunEventSink;
-}): Promise<CompiledCompileResult>;