@interf/compiler 0.9.5 → 0.16.0

package/dist/packages/{project-model → project}/source-config.js

@@ -1,24 +1,24 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { isAbsolute, join, relative, resolve, sep } from "node:path";
-import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
-import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { getCompiledMethod } from "../method-package/method-definitions.js";
+import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
+import { readJsonFileWithSchema } from "../contracts/utils/parse.js";
+import { getCompiledMethod } from "../methods/package/method-definitions.js";
 import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.js";
-import { slugify } from "../shared/naming.js";
-import { assertPathWithinRoot, isPathWithinRoot } from "../shared/path-guards.js";
-import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
-import { projectInterfRoot, PROJECT_INTERF_DIR } from "./project-paths.js";
-export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
-export const SOURCE_FOLDER_CONFIG_PATH = `${PROJECT_INTERF_DIR}/${SOURCE_FOLDER_CONFIG_FILE}`;
-export function sourceFolderConfigPath(sourcePath) {
-    return join(projectInterfRoot(sourcePath), SOURCE_FOLDER_CONFIG_FILE);
+import { slugify } from "../contracts/utils/naming.js";
+import { assertPathWithinRoot, isPathWithinRoot } from "../contracts/utils/path-guards.js";
+import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../engine/compile/compiled-paths.js";
+import { asPreparationDataDir, preparationConfigPath, PREPARATION_CONFIG_FILENAME, } from "../contracts/lib/preparation-paths.js";
+export const SOURCE_FOLDER_CONFIG_FILE = PREPARATION_CONFIG_FILENAME;
+export const SOURCE_FOLDER_CONFIG_PATH = SOURCE_FOLDER_CONFIG_FILE;
+export function sourceFolderConfigPath(prepDataDir) {
+    return preparationConfigPath(asPreparationDataDir(prepDataDir));
 }
-export function resolveSourceFolderConfigPath(sourcePath) {
-    return sourceFolderConfigPath(sourcePath);
+export function resolveSourceFolderConfigPath(prepDataDir) {
+    return sourceFolderConfigPath(prepDataDir);
 }
 function readSourceFolderConfigFile(filePath) {
     return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
@@ -55,8 +55,8 @@ export function fingerprintReadinessChecks(checks) {
         .digest("hex")
         .slice(0, 16);
 }
-export function loadSourceFolderConfig(sourcePath) {
-    const filePath = resolveSourceFolderConfigPath(sourcePath);
+export function loadSourceFolderConfig(prepDataDir) {
+    const filePath = resolveSourceFolderConfigPath(prepDataDir);
     if (!existsSync(filePath))
         return null;
     return readSourceFolderConfigFile(filePath);
@@ -100,9 +100,9 @@ export function findSourcePreparationConfig(config, preparationName) {
 export function configuredSourceFolderPath(config) {
     return config?.source_folder?.path ?? null;
 }
-export function resolveConfiguredSourceFolderPath(sourcePath, config = loadSourceFolderConfig(sourcePath)) {
+export function resolveConfiguredSourceFolderPath(prepDataDir, config = loadSourceFolderConfig(prepDataDir)) {
     const configuredPath = configuredSourceFolderPath(config);
-    return configuredPath ? resolve(sourcePath, configuredPath) : null;
+    return configuredPath ? resolve(prepDataDir, configuredPath) : null;
 }
 function toWritableSourceProjectConfig(config) {
     const preparations = config?.preparations ?? [];
@@ -130,17 +130,17 @@ function toWritableSourcePreparationConfig(preparation) {
         checks: preparation.checks,
     };
 }
-export function saveSourceFolderConfig(sourcePath, config) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function saveSourceFolderConfig(prepDataDir, config) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const mergedConfig = {
         ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
         ...config,
     };
-    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
-    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
+    mkdirSync(prepDataDir, { recursive: true });
+    writeFileSync(sourceFolderConfigPath(prepDataDir), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
 }
-export function appendSourcePreparationChecks(sourcePath, preparationName, checks) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function appendSourcePreparationChecks(prepDataDir, preparationName, checks) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const currentPreparation = findSourcePreparationConfig(existing, preparationName);
     const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
     const currentChecks = currentPreparation?.checks ?? [];
@@ -152,15 +152,15 @@ export function appendSourcePreparationChecks(sourcePath, preparationName, check
         }),
         checks: [...currentChecks, ...checks],
     };
-    saveSourceFolderConfig(sourcePath, {
+    saveSourceFolderConfig(prepDataDir, {
         preparations: [
             nextPreparation,
             ...otherPreparations,
         ],
     });
 }
-export function upsertSourcePreparationConfig(sourcePath, preparationConfig, options = {}) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function upsertSourcePreparationConfig(prepDataDir, preparationConfig, options = {}) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const preparations = listSourcePreparationConfigs(existing);
     const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
     const existingIndex = preparations.findIndex((entry) => candidateNames.includes(entry.name));
@@ -170,17 +170,17 @@ export function upsertSourcePreparationConfig(sourcePath, preparationConfig, opt
     else {
         preparations.push(normalizeSourcePreparationConfig(preparationConfig));
     }
-    saveSourceFolderConfig(sourcePath, {
+    saveSourceFolderConfig(prepDataDir, {
         preparations,
     });
 }
-export function removeSourcePreparationConfig(sourcePath, preparationName) {
-    const existing = loadSourceFolderConfig(sourcePath);
+export function removeSourcePreparationConfig(prepDataDir, preparationName) {
+    const existing = loadSourceFolderConfig(prepDataDir);
     const preparations = listSourcePreparationConfigs(existing);
     const nextPreparations = preparations.filter((entry) => entry.name !== preparationName);
     if (nextPreparations.length === preparations.length)
         return false;
-    saveSourceFolderConfig(sourcePath, {
+    saveSourceFolderConfig(prepDataDir, {
         preparations: nextPreparations,
     });
     return true;
@@ -214,8 +214,8 @@ export function loadCompiledPreparationConfig(compiledPath) {
     const config = readInterfConfig(compiledPath);
     if (!config)
         return null;
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(projectPath));
+    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
     const defaultPreparationPath = configuredPreparations.length === 1
         ? configuredPreparations[0].path
         : `./${config.name}`;
@@ -225,10 +225,10 @@ export function loadCompiledPreparationConfig(compiledPath) {
     const preparationPath = sourceBinding
         ? (() => {
             const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
-            if (!isPathWithinRoot(projectPath, sourceAbsolutePath)) {
+            if (!isPathWithinRoot(prepDataDir, sourceAbsolutePath)) {
                 return sourceAbsolutePath;
             }
-            return relative(projectPath, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
+            return relative(prepDataDir, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
         })()
         : defaultPreparationPath;
     return sourcePreparationConfigFromInterfConfig(config, preparationPath);
@@ -240,8 +240,8 @@ export function saveCompiledInterfConfig(compiledPath, config) {
 }
 export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
     const current = readInterfConfig(compiledPath);
-    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const preparationAbsolutePath = resolveSourcePreparationPath(projectPath, preparationConfig);
+    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const preparationAbsolutePath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
     const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
     const methodId = methodIdForSourcePreparationConfig(preparationConfig)
         ?? methodIdForSourcePreparationConfig(current)
@@ -259,7 +259,7 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
         ...(!current ? {
             type: "compiled",
             source: {
-                path: "./raw",
+                path: preparationRelativePath,
             },
         } : {}),
         type: "compiled",
@@ -275,18 +275,17 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
         checks: preparationConfig.checks,
         method_origin: methodOrigin,
         source: {
-            path: current?.source?.path ?? "./raw",
+            path: preparationRelativePath,
             control_path: defaultControlPathForCompiled(compiledPath),
             preparation_path: preparationRelativePath,
         },
     };
     const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
     if (methodChanged) {
-        const sourcePath = projectPath;
-        const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+        const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
         seedCompiledMethodPackage({
             compiledPath,
-            sourcePath,
+            prepDataDir,
             methodId: selectedMethod.id,
         });
     }
@@ -298,7 +297,7 @@ function buildLoadedTestSpec(options) {
         return null;
     const testId = options.id ?? slugify(options.name);
     return {
-        id: options.targetType === "raw" ? `${testId}-raw` : testId,
+        id: options.targetType === "source-files" ? `${testId}-source-files` : testId,
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
@@ -307,8 +306,8 @@ function buildLoadedTestSpec(options) {
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
-    const { sourcePath, targetName, targetType = "compiled" } = options;
-    const config = loadSourceFolderConfig(sourcePath);
+    const { prepDataDir, targetName, targetType = "compiled" } = options;
+    const config = loadSourceFolderConfig(prepDataDir);
     if (!config)
         return null;
     const preparations = listSourcePreparationConfigs(config);
@@ -321,14 +320,14 @@ export function buildTestSpecFromSourceFolderConfig(options) {
             : getDefaultSourcePreparationConfig(config);
     if (!match)
         return null;
-    const configPath = resolveSourceFolderConfigPath(sourcePath);
+    const configPath = resolveSourceFolderConfigPath(prepDataDir);
     return buildLoadedTestSpec({
         id: match.id,
         name: match.name,
         about: match.about,
         checks: match.checks,
         targetType,
-        filePath: targetType === "raw"
+        filePath: targetType === "source-files"
             ? `${configPath}#preparations/${match.name}:source-files`
             : `${configPath}#preparations/${match.name}:portable-context`,
         defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
@@ -345,17 +344,46 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
         about: config.about,
         checks: config.checks ?? [],
         targetType,
-        filePath: targetType === "raw"
-            ? `${configPath}#checks:file-as-is`
+        filePath: targetType === "source-files"
+            ? `${configPath}#checks:source-files`
             : `${configPath}#checks:compiled`,
         defaultDescription: "Derived from checks in the portable context config.",
     });
 }
-export function resolveSourcePreparationPath(projectPath, preparationConfig) {
+/**
+ * System path prefixes the runtime must never operate on, even when an
+ * absolute `preparation.path` was authored by hand. The schema-level
+ * refinement in `SourcePreparationConfigSchema` is the primary line of
+ * defense; this is the in-process backstop for callers that hand-craft a
+ * SourcePreparationConfig at runtime (e.g. method authoring helpers that
+ * construct a config from an InterfConfig).
+ */
+const FORBIDDEN_PREPARATION_PATH_PREFIXES = [
+    "/etc",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/var/run",
+    "/var/lib",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/boot",
+];
+function rejectForbiddenPreparationPath(absolutePath) {
+    for (const prefix of FORBIDDEN_PREPARATION_PATH_PREFIXES) {
+        if (absolutePath === prefix || absolutePath.startsWith(`${prefix}/`)) {
+            throw new Error(`Preparation path may not target system directory ${prefix}: ${absolutePath}`);
+        }
+    }
+}
+export function resolveSourcePreparationPath(prepDataDir, preparationConfig) {
     const configuredPath = preparationConfig.path.trim();
-    const resolvedPath = resolve(projectPath, configuredPath);
+    const resolvedPath = resolve(prepDataDir, configuredPath);
     if (isAbsolute(configuredPath)) {
+        rejectForbiddenPreparationPath(resolvedPath);
         return resolvedPath;
     }
-    return assertPathWithinRoot(projectPath, resolvedPath, "Source folder path");
+    rejectForbiddenPreparationPath(resolvedPath);
+    return assertPathWithinRoot(prepDataDir, resolvedPath, "Source folder path");
 }

package/dist/packages/{project-model → project}/source-folders.d.ts

@@ -1,11 +1,11 @@
-export declare function listVisibleSourceFolders(projectPath: string): string[];
+export declare function listVisibleSourceFolders(prepDataDir: string): string[];
 export declare function isReservedSourcePreparationPath(relativePath: string): boolean;
-export declare function normalizeSourcePreparationPathForConfig(projectPath: string, value: string): string;
+export declare function normalizeSourcePreparationPathForConfig(prepDataDir: string, value: string): string;
 export declare function defaultPreparationNameForPath(sourceFolderPath: string): string;
-export declare function findSingleSourceFolderCandidate(projectPath: string): string | null;
-export declare function listSourceFolderChoices(projectPath?: string): Array<{
+export declare function findSingleSourceFolderCandidate(prepDataDir: string): string | null;
+export declare function listSourceFolderChoices(prepDataDir?: string): Array<{
     value: string;
     label: string;
     hint: string;
 }>;
-export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;
+export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", prepDataDir?: string): string;

package/dist/packages/{project-model → project}/source-folders.js

@@ -1,8 +1,8 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, sep } from "node:path";
-import { slugify } from "../shared/naming.js";
+import { slugify } from "../contracts/utils/naming.js";
 import { resolveSourcePreparationPath } from "./source-config.js";
-import { isPathWithinRoot } from "../shared/path-guards.js";
+import { isPathWithinRoot } from "../contracts/utils/path-guards.js";
 const DEFAULT_PREPARATION_NAME = "default";
 const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     ".DS_Store",
@@ -12,10 +12,10 @@ const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     "interf.json",
     "node_modules",
 ]);
-export function listVisibleSourceFolders(projectPath) {
+export function listVisibleSourceFolders(prepDataDir) {
     let rootEntries = [];
     try {
-        rootEntries = readdirSync(projectPath);
+        rootEntries = readdirSync(prepDataDir);
     }
     catch {
         return [];
@@ -24,7 +24,7 @@ export function listVisibleSourceFolders(projectPath) {
     const visibleDirectories = [];
     for (const entry of visibleEntries) {
         try {
-            const entryPath = join(projectPath, entry);
+            const entryPath = join(prepDataDir, entry);
             if (statSync(entryPath).isDirectory()) {
                 visibleDirectories.push(entry);
             }
@@ -42,14 +42,14 @@ export function isReservedSourcePreparationPath(relativePath) {
         normalized === ".interf" ||
         normalized.startsWith(".interf/");
 }
-export function normalizeSourcePreparationPathForConfig(projectPath, value) {
+export function normalizeSourcePreparationPathForConfig(prepDataDir, value) {
     const trimmedValue = value.trim();
-    const resolvedPath = resolveSourcePreparationPath(projectPath, { path: trimmedValue });
-    const relativePath = relative(projectPath, resolvedPath).split(sep).join("/") || ".";
+    const resolvedPath = resolveSourcePreparationPath(prepDataDir, { path: trimmedValue });
+    const relativePath = relative(prepDataDir, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
         throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
     }
-    if (isAbsolute(trimmedValue) && !isPathWithinRoot(projectPath, resolvedPath)) {
+    if (isAbsolute(trimmedValue) && !isPathWithinRoot(prepDataDir, resolvedPath)) {
         if (!existsSync(resolvedPath)) {
             throw new Error("Pick an existing source folder.");
         }
@@ -77,22 +77,22 @@ export function defaultPreparationNameForPath(sourceFolderPath) {
         .filter((segment) => segment.length > 0 && segment !== ".");
     return slugify(segments[segments.length - 1] ?? "") || DEFAULT_PREPARATION_NAME;
 }
-export function findSingleSourceFolderCandidate(projectPath) {
-    const visibleDirectories = listVisibleSourceFolders(projectPath);
+export function findSingleSourceFolderCandidate(prepDataDir) {
+    const visibleDirectories = listVisibleSourceFolders(prepDataDir);
     if (visibleDirectories.length !== 1) {
         return null;
     }
     return `./${visibleDirectories[0]}`;
 }
-export function listSourceFolderChoices(projectPath = process.cwd()) {
-    return listVisibleSourceFolders(projectPath).map((entry) => ({
+export function listSourceFolderChoices(prepDataDir = process.cwd()) {
+    return listVisibleSourceFolders(prepDataDir).map((entry) => ({
         value: `./${entry}`,
         label: entry,
         hint: `Use ./${entry} as the source folder`,
     }));
 }
-export function defaultSourcePreparationPathForPrompt(name, introStyle, projectPath = process.cwd()) {
-    const namedFolderPath = join(projectPath, name);
+export function defaultSourcePreparationPathForPrompt(name, introStyle, prepDataDir = process.cwd()) {
+    const namedFolderPath = join(prepDataDir, name);
     if (existsSync(namedFolderPath)) {
         try {
             if (statSync(namedFolderPath).isDirectory()) {
@@ -104,7 +104,7 @@ export function defaultSourcePreparationPathForPrompt(name, introStyle, projectP
         }
     }
     if (introStyle === "first") {
-        return findSingleSourceFolderCandidate(projectPath) ?? `./${name}`;
+        return findSingleSourceFolderCandidate(prepDataDir) ?? `./${name}`;
     }
     return `./${name}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.9.5",
+  "version": "0.16.0",
   "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": {
@@ -19,17 +19,17 @@
       "import": "./dist/packages/contracts/index.js"
     },
     "./execution": {
-      "types": "./dist/packages/execution/index.d.ts",
-      "import": "./dist/packages/execution/index.js"
+      "types": "./dist/packages/engine/execution/index.d.ts",
+      "import": "./dist/packages/engine/execution/index.js"
     },
     "./local-service": {
-      "types": "./dist/packages/local-service/index.d.ts",
-      "import": "./dist/packages/local-service/index.js"
+      "types": "./dist/packages/engine/index.d.ts",
+      "import": "./dist/packages/engine/index.js"
     },
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc && chmod 755 dist/bin.js",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true});require('fs').rmSync('.tsbuildinfo',{force:true})\" && tsc && chmod 755 dist/bin.js",
     "dev": "tsc --watch",
     "web:dev": "npm --prefix apps/compiler-ui run dev",
     "web:typecheck": "npm --prefix apps/compiler-ui run typecheck",
@@ -54,7 +54,6 @@
     "dist",
     "builtin-methods",
     "agent-skills",
-    "CHANGELOG.md",
     "TRADEMARKS.md"
   ],
   "publishConfig": {
@@ -68,7 +67,7 @@
     "claude",
     "codex"
   ],
-  "license": "Apache-2.0",
+  "license": "UNLICENSED",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/interf-labs/interf.git"
@@ -82,6 +81,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.9.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "chalk": "^5.4.1",
     "yargs": "^17.7.2",
     "zod": "^4.3.6"

package/CHANGELOG.md

@@ -1,93 +0,0 @@
-# Changelog
-
-Interf follows practical release notes: what changed, why it matters, and what
-still needs cleanup. Dates use the local release date.
-
-## 0.9.5 - 2026-05-02
-
-### Changed
-
-- Made the local service the execution gate for observable work. Prepare runs,
-  readiness-check runs, and agent-backed work now route through service-owned
-  run resources so CLI and UI see the same status.
-- Centralized user action definitions under the local-service package. UI
-  dialogs and CLI flows should render the same TypeScript/Zod-backed action
-  contract instead of carrying duplicate labels, prompts, and request fields.
-- Separated structured UI controls from freeform chat. Buttons submit typed
-  service requests; chat remains an explicit proposal surface.
-- Tightened Method removal. Removing a Method clears stale saved Preparation
-  selections instead of blocking on old references; preparing still requires an
-  explicit Method.
-- Expanded smoke coverage around CLI behavior, service-backed actions,
-  Method mutations, run visibility, and package boundary rules.
-
-### Fixed
-
-- Removed the UI path that pasted prepare prompts into chat instead of running
-  the typed prepare action.
-- Fixed action dialog/menu event handling so form input focus does not close the
-  parent row menu.
-- Fixed service and CLI behavior that could hide observable work in package
-  calls instead of a visible run.
-
-### Still To Watch
-
-- `apps/compiler-ui/app/page.tsx` and `src/packages/local-service/runtime.ts`
-  are still too large. Future cleanup should split them only when it reduces
-  reader trace depth or state in memory.
-- Some lower-level tests and package helpers still call package primitives
-  directly. That is correct for unit tests and package oracles; it is wrong for
-  user-visible prepare/check/Method actions.
-- Any remaining compatibility path for old product nouns should be listed for
-  founder review before removal. Do not add new compatibility shims unless the
-  current product contract requires them.
-
-## 0.9.4 - 2026-05-01
-
-### Changed
-
-- Kept setup separate from prepare runs. Creating or editing a Preparation is a
-  deterministic config action; preparing files is a visible run.
-- Simplified retry behavior by removing the partial stage-retry path. A prepare
-  run should be understandable from one run record and one filesystem state.
-- Stabilized trace rendering for active and failed runs, including failed-stage
-  layout and pending-run navigation.
-- Improved portable-context status and expected-output display so the UI
-  distinguishes current output from Method-planned output.
-
-### Fixed
-
-- Repaired missing local Method packages before prepare runs when the selected
-  Method can be reseeded from the current Interf Workspace.
-- Fixed packaged UI availability after local builds.
-- Accepted relative portable-context wikilinks and markdown-source summary links
-  during validation.
-- Stabilized the publish smoke gate environment.
-
-## 0.9.3 - 2026-04-30
-
-### Changed
-
-- Completed the public Preparation/Method vocabulary pass across CLI, service,
-  UI state, runtime records, docs, and tests.
-- Removed legacy 0.8 compatibility surfaces and project-model compiler shims
-  that forced readers to translate old product terms.
-- Moved package boundaries toward one owner per primitive: contracts for shared
-  schemas, project-model for Interf Workspace config, compiler for portable
-  context writes, testing for readiness-check runs, and local-service for read
-  models.
-- Added the source reader map in `src/README.md` so contributors can trace
-  `interf compile` without grepping through the whole repo first.
-- Expanded public CLI smoke coverage and release acceptance checks.
-
-### Fixed
-
-- Fixed release readiness blockers around CLI parsing, status output,
-  verification, UI layout, executor acceptance, and package metadata.
-- Served Interf Compiler UI from the static export used by `interf web`.
-
-### Cleanup Principle
-
-Every 0.9 patch is judged by one rubric: reduce the number of files a reader
-must trace, or reduce the number of facts a reader must hold in memory. If a
-change does neither, it should not be part of the cleanup.