@interf/compiler 0.21.0 → 0.22.2

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

@@ -1,16 +1,16 @@
-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";
+import { listVerifiableContextsForSourceFolder, } from "./interf-detect.js";
+import { createVerifiableContext, ensureVerifiableContextScaffold, } from "./interf-scaffold.js";
+import { listSourcePreparationConfigs, loadVerifiableContextPreparationConfig, loadSourceFolderConfig, resolveSourcePreparationPath, sourcePreparationConfigFromInterfConfig, syncVerifiableContextInterfConfigFromSourcePreparationConfig, } from "./source-config.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
 export function listSavedPreparationEntries(prepDataDir) {
     const builtEntries = new Map();
-    for (const builtContext of listPortableContextsForSourceFolder(prepDataDir)) {
-        const preparationConfig = loadCompiledPreparationConfig(builtContext.path)
+    for (const builtContext of listVerifiableContextsForSourceFolder(prepDataDir)) {
+        const preparationConfig = loadVerifiableContextPreparationConfig(builtContext.path)
             ?? sourcePreparationConfigFromInterfConfig(builtContext.config);
         builtEntries.set(builtContext.config.name, {
             config: preparationConfig,
             path: builtContext.path,
-            localDraft: builtContext.config.method_origin?.local_draft === true,
+            localDraft: builtContext.config.build_plan_origin?.local_draft === true,
         });
     }
     const entries = new Map();
@@ -24,26 +24,26 @@ export function listSavedPreparationEntries(prepDataDir) {
     }
     return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
 }
-export function findBuiltPortableContextPath(prepDataDir, preparationName) {
+export function findBuiltVerifiableContextPath(prepDataDir, preparationName) {
     return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.path ?? null;
 }
 export function findSavedPreparationConfig(prepDataDir, preparationName) {
     return listSavedPreparationEntries(prepDataDir).find((entry) => entry.config.name === preparationName)?.config ?? null;
 }
-export function createPortableContextFromConfig(prepDataDir, preparationConfig) {
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
+export function createVerifiableContextFromConfig(prepDataDir, preparationConfig) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
     const sourceFolderPath = resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const compiledPath = createCompiled(preparationConfig.name, prepDataDir, methodId, preparationConfig.about, sourceFolderPath);
-    syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig);
-    return compiledPath;
+    const verifiableContextPath = createVerifiableContext(preparationConfig.name, prepDataDir, buildPlanId, preparationConfig.about, sourceFolderPath);
+    syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig);
+    return verifiableContextPath;
 }
-export function ensurePortableContextFromConfig(prepDataDir, preparationConfig) {
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_METHOD_ID;
-    const existingPath = findBuiltPortableContextPath(prepDataDir, preparationConfig.name);
+export function ensureVerifiableContextFromConfig(prepDataDir, preparationConfig) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig) ?? DEFAULT_BUILD_PLAN_ID;
+    const existingPath = findBuiltVerifiableContextPath(prepDataDir, preparationConfig.name);
     if (existingPath) {
-        ensurePortableContextScaffold(prepDataDir, preparationConfig.name, methodId);
-        syncCompiledInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
+        ensureVerifiableContextScaffold(prepDataDir, preparationConfig.name, buildPlanId);
+        syncVerifiableContextInterfConfigFromSourcePreparationConfig(existingPath, preparationConfig);
         return existingPath;
     }
-    return createPortableContextFromConfig(prepDataDir, preparationConfig);
+    return createVerifiableContextFromConfig(prepDataDir, preparationConfig);
 }

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

@@ -14,10 +14,10 @@ export interface WritableSourceProjectConfig {
     source_folder?: SourceFolderBinding;
     preparations?: SourcePreparationConfig[];
 }
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
 export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
-export declare function resolvePreparationCompileMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
-export declare function resolvePreparationCompileMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
+export declare function resolvePreparationBuildMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
+export declare function resolvePreparationBuildMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
 export declare function getDefaultSourcePreparationConfig(config: SourceFolderConfig | null): SourcePreparationConfig | null;
 export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
 export declare function configuredSourceFolderPath(config: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
@@ -28,19 +28,19 @@ export declare function upsertSourcePreparationConfig(prepDataDir: string, prepa
     matchName?: string;
 }): void;
 export declare function removeSourcePreparationConfig(prepDataDir: 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 buildMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
+export declare function buildMaxLoops(maxLoops: number | null | undefined): number | undefined;
 export declare function sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
-export declare function loadCompiledPreparationConfig(compiledPath: string): SourcePreparationConfig | null;
-export declare function saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
-export declare function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
+export declare function loadVerifiableContextPreparationConfig(verifiableContextPath: string): SourcePreparationConfig | null;
+export declare function saveVerifiableContextInterfConfig(verifiableContextPath: string, config: InterfConfig): InterfConfig;
+export declare function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
     prepDataDir: string;
     targetName?: string | null;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function buildTestSpecFromCompiledPreparationConfig(options: {
-    compiledPath: string;
+export declare function buildTestSpecFromPreparationConfig(options: {
+    verifiableContextPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
 export declare function resolveSourcePreparationPath(prepDataDir: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;

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

@@ -1,16 +1,16 @@
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import { refreshCompiledBootstrapGuidance } from "../engine/agents/lib/compiled-bootstrap.js";
+import { refreshVerifiableContextBootstrapGuidance } from "../engine/agents/lib/verifiable-context-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
-import { seedCompiledMethodPackage } from "../methods/package/interf-method-package.js";
+import { seedVerifiableContextBuildPlanPackage } from "../build-plans/package/interf-build-plan-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 { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.js";
 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 { defaultControlPathForVerifiableContext, resolveSourceControlPathForVerifiableContext, verifiableContextInterfConfigPath, verifiableContextInterfRoot, } from "../engine/build/verifiable-context-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;
@@ -61,18 +61,18 @@ export function loadSourceFolderConfig(prepDataDir) {
         return null;
     return readSourceFolderConfigFile(filePath);
 }
-export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForSourcePreparationConfig } from "../build-plans/build-plan-resolution.js";
 function normalizeSourcePreparationConfig(preparationConfig) {
-    const method = methodIdForSourcePreparationConfig(preparationConfig);
+    const buildPlan = buildPlanIdForSourcePreparationConfig(preparationConfig);
     return {
         ...preparationConfig,
-        ...(method ? { method } : {}),
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
     };
 }
 export function listSourcePreparationConfigs(config) {
     return (config?.preparations ?? []).map((preparation) => normalizeSourcePreparationConfig(preparation));
 }
-export function resolvePreparationCompileMaxAttempts(preparationConfig, override = null) {
+export function resolvePreparationBuildMaxAttempts(preparationConfig, override = null) {
     const configured = override ?? preparationConfig.max_attempts ?? null;
     if (configured == null)
         return null;
@@ -81,7 +81,7 @@ export function resolvePreparationCompileMaxAttempts(preparationConfig, override
         return 1;
     return Math.min(5, normalized);
 }
-export function resolvePreparationCompileMaxLoops(preparationConfig, override = null) {
+export function resolvePreparationBuildMaxLoops(preparationConfig, override = null) {
     const configured = override ?? preparationConfig.max_loops ?? null;
     if (configured == null)
         return null;
@@ -119,12 +119,12 @@ function toWritableSourceProjectConfig(config) {
     };
 }
 function toWritableSourcePreparationConfig(preparation) {
-    const method = methodIdForSourcePreparationConfig(preparation);
+    const buildPlan = buildPlanIdForSourcePreparationConfig(preparation);
     return {
         name: preparation.name,
         path: preparation.path,
         ...(preparation.about ? { about: preparation.about } : {}),
-        ...(method ? { method } : {}),
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
@@ -189,22 +189,22 @@ export function removeSourcePreparationConfig(prepDataDir, preparationName) {
     });
     return true;
 }
-export function compiledMaxAttempts(maxAttempts) {
+export function buildMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
-    return resolvePreparationCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+    return resolvePreparationBuildMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
 }
-export function compiledMaxLoops(maxLoops) {
+export function buildMaxLoops(maxLoops) {
     if (maxLoops == null)
         return undefined;
-    return resolvePreparationCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+    return resolvePreparationBuildMaxLoops({ max_loops: maxLoops }, null) ?? 1;
 }
 export function sourcePreparationConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
     return {
         name: config.name,
         path: preparationPath,
         ...(config.about ? { about: config.about } : {}),
-        method: config.method,
+        build_plan: config.build_plan,
         ...(typeof config.max_attempts === "number"
             ? { max_attempts: config.max_attempts }
             : {}),
@@ -214,11 +214,11 @@ export function sourcePreparationConfigFromInterfConfig(config, preparationPath
         checks: config.checks ?? [],
     };
 }
-export function loadCompiledPreparationConfig(compiledPath) {
-    const config = readInterfConfig(compiledPath);
+export function loadVerifiableContextPreparationConfig(verifiableContextPath) {
+    const config = readInterfConfig(verifiableContextPath);
     if (!config)
         return null;
-    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
     const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(prepDataDir));
     const defaultPreparationPath = configuredPreparations.length === 1
         ? configuredPreparations[0].path
@@ -228,7 +228,7 @@ export function loadCompiledPreparationConfig(compiledPath) {
         : null;
     const preparationPath = sourceBinding
         ? (() => {
-            const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
+            const sourceAbsolutePath = resolve(verifiableContextPath, sourceBinding);
             if (!isPathWithinRoot(prepDataDir, sourceAbsolutePath)) {
                 return sourceAbsolutePath;
             }
@@ -237,40 +237,40 @@ export function loadCompiledPreparationConfig(compiledPath) {
         : defaultPreparationPath;
     return sourcePreparationConfigFromInterfConfig(config, preparationPath);
 }
-export function saveCompiledInterfConfig(compiledPath, config) {
-    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
-    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
+export function saveVerifiableContextInterfConfig(verifiableContextPath, config) {
+    mkdirSync(verifiableContextInterfRoot(verifiableContextPath), { recursive: true });
+    writeFileSync(verifiableContextInterfConfigPath(verifiableContextPath), JSON.stringify(config, null, 2) + "\n");
     return config;
 }
-export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
-    const current = readInterfConfig(compiledPath);
-    const prepDataDir = resolveSourceControlPathForCompiled(compiledPath);
+export function syncVerifiableContextInterfConfigFromSourcePreparationConfig(verifiableContextPath, preparationConfig) {
+    const current = readInterfConfig(verifiableContextPath);
+    const prepDataDir = resolveSourceControlPathForVerifiableContext(verifiableContextPath);
     const preparationAbsolutePath = resolveConfiguredSourceFolderPath(prepDataDir) ??
         resolveSourcePreparationPath(prepDataDir, preparationConfig);
-    const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
-    const methodId = methodIdForSourcePreparationConfig(preparationConfig)
-        ?? methodIdForSourcePreparationConfig(current)
-        ?? DEFAULT_METHOD_ID;
-    const methodChanged = current?.method !== undefined && current.method !== methodId;
-    const methodOrigin = methodChanged || !current?.method_origin
+    const preparationRelativePath = relative(verifiableContextPath, preparationAbsolutePath).split(sep).join("/") || ".";
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparationConfig)
+        ?? buildPlanIdForSourcePreparationConfig(current)
+        ?? DEFAULT_BUILD_PLAN_ID;
+    const buildPlanChanged = current?.build_plan !== undefined && current.build_plan !== buildPlanId;
+    const buildPlanOrigin = buildPlanChanged || !current?.build_plan_origin
         ? {
-            selected: methodId,
+            selected: buildPlanId,
             local_draft: false,
         }
-        : current.method_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, method: _ignoredMethod, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, method_origin: _ignoredMethodOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+        : current.build_plan_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, build_plan: _ignoredBuildPlan, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, build_plan_origin: _ignoredBuildPlanOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
     const nextConfig = {
         ...passthrough,
         ...(!current ? {
-            type: "compiled",
+            type: "verifiable-context",
             source: {
                 path: preparationRelativePath,
             },
         } : {}),
-        type: "compiled",
+        type: "verifiable-context",
         name: preparationConfig.name,
         ...(preparationConfig.about ? { about: preparationConfig.about } : {}),
-        method: methodId,
+        build_plan: buildPlanId,
         ...(typeof preparationConfig.max_attempts === "number"
             ? { max_attempts: preparationConfig.max_attempts }
             : {}),
@@ -278,23 +278,23 @@ export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath
             ? { max_loops: preparationConfig.max_loops }
             : {}),
         checks: preparationConfig.checks,
-        method_origin: methodOrigin,
+        build_plan_origin: buildPlanOrigin,
         source: {
             path: preparationRelativePath,
-            control_path: defaultControlPathForCompiled(compiledPath),
+            control_path: defaultControlPathForVerifiableContext(verifiableContextPath),
             preparation_path: preparationRelativePath,
         },
     };
-    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
-    if (methodChanged) {
-        const selectedMethod = getCompiledMethod(methodId, { prepDataDir });
-        seedCompiledMethodPackage({
-            compiledPath,
+    const saved = saveVerifiableContextInterfConfig(verifiableContextPath, nextConfig);
+    if (buildPlanChanged) {
+        const selectedBuildPlan = getBuildPlan(buildPlanId, { prepDataDir });
+        seedVerifiableContextBuildPlanPackage({
+            verifiableContextPath,
             prepDataDir,
-            methodId: selectedMethod.id,
+            buildPlanId: selectedBuildPlan.id,
         });
     }
-    refreshCompiledBootstrapGuidance(compiledPath);
+    refreshVerifiableContextBootstrapGuidance(verifiableContextPath);
     return saved;
 }
 function buildLoadedTestSpec(options) {
@@ -302,7 +302,7 @@ function buildLoadedTestSpec(options) {
         return null;
     const testId = options.id ?? slugify(options.name);
     return {
-        id: options.targetType === "source-files" ? `${testId}-source-files` : testId,
+        id: options.targetType === "source-files" ? `${testId}-source-files` : `${testId}-verifiable-context`,
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
@@ -311,7 +311,7 @@ function buildLoadedTestSpec(options) {
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
-    const { prepDataDir, targetName, targetType = "compiled" } = options;
+    const { prepDataDir, targetName, targetType = "verifiable-context" } = options;
     const config = loadSourceFolderConfig(prepDataDir);
     if (!config)
         return null;
@@ -334,14 +334,14 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         targetType,
         filePath: targetType === "source-files"
             ? `${configPath}#preparations/${match.name}:source-files`
-            : `${configPath}#preparations/${match.name}:portable-context`,
+            : `${configPath}#preparations/${match.name}:verifiable-context`,
         defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
     });
 }
-export function buildTestSpecFromCompiledPreparationConfig(options) {
-    const { compiledPath, targetType = "compiled" } = options;
-    const config = readInterfConfig(compiledPath);
-    const configPath = compiledInterfConfigPath(compiledPath);
+export function buildTestSpecFromPreparationConfig(options) {
+    const { verifiableContextPath, targetType = "verifiable-context" } = options;
+    const config = readInterfConfig(verifiableContextPath);
+    const configPath = verifiableContextInterfConfigPath(verifiableContextPath);
     if (!config)
         return null;
     return buildLoadedTestSpec({
@@ -351,8 +351,8 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
         targetType,
         filePath: targetType === "source-files"
             ? `${configPath}#checks:source-files`
-            : `${configPath}#checks:compiled`,
-        defaultDescription: "Derived from checks in the portable context config.",
+            : `${configPath}#checks:verifiable-context`,
+        defaultDescription: "Derived from checks in the verifiable-context config.",
     });
 }
 /**
@@ -360,7 +360,7 @@ export function buildTestSpecFromCompiledPreparationConfig(options) {
  * 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
+ * SourcePreparationConfig at runtime (e.g. Build Plan authoring helpers that
  * construct a config from an InterfConfig).
  */
 const FORBIDDEN_PREPARATION_PATH_PREFIXES = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.21.0",
-  "description": "Interf compiles source files into verifiable Artifacts and writes portable context agents can read.",
+  "version": "0.22.2",
+  "description": "Interf builds verifiable context for agents from your files.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -19,9 +19,9 @@
   "scripts": {
     "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 src/apps/compiler-ui run dev",
-    "web:typecheck": "npm --prefix src/apps/compiler-ui run typecheck",
-    "web:build": "node scripts/web/build-compiler-ui.mjs",
+    "web:dev": "npm --prefix src/apps/interf-ui run dev",
+    "web:typecheck": "npm --prefix src/apps/interf-ui run typecheck",
+    "web:build": "node scripts/web/build-interf-ui.mjs",
     "docs:sync-public": "node scripts/docs/sync-public-repo.mjs",
     "docs:check-public": "node scripts/docs/sync-public-repo.mjs --check",
     "test:smoke": "npm run build && node --test test/**/*.test.mjs",
@@ -33,16 +33,16 @@
     "test:acceptance": "npm run build && node scripts/acceptance/release.mjs",
     "test:release": "npm run web:typecheck && npm test && node scripts/acceptance/release.mjs && npm run web:build",
     "test:acceptance-live": "npm run build && node scripts/acceptance/live.mjs",
-    "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance/targeted.mjs create-compiled",
-    "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance/targeted.mjs compiled-query",
-    "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance/targeted.mjs self-improving-compile",
-    "prepublishOnly": "node scripts/release/prepublish-gate.mjs"
+    "test:acceptance-quick:create-build": "npm run build && node scripts/acceptance/targeted.mjs create-build",
+    "test:acceptance-quick:context-query": "npm run build && node scripts/acceptance/targeted.mjs context-query",
+    "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance/targeted.mjs self-improving-build",
+    "prepublishOnly": "node scripts/release/prepublish-gate.mjs",
+    "prepack": "node scripts/release/package-readme.mjs --write",
+    "postpack": "node scripts/release/package-readme.mjs --clean"
   },
   "files": [
     "dist",
-    "public-repo",
-    "LICENSE.md",
-    "TRADEMARKS.md"
+    "public-repo"
   ],
   "publishConfig": {
     "access": "public"
@@ -55,14 +55,14 @@
     "claude",
     "codex"
   ],
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "SEE LICENSE IN public-repo/LICENSE.md",
   "author": "Interf Inc.",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/interf-labs/compiler.git"
+    "url": "git+https://github.com/interf-labs/interf.git"
   },
   "bugs": {
-    "url": "https://github.com/interf-labs/compiler/issues"
+    "url": "https://github.com/interf-labs/interf/issues"
   },
   "homepage": "https://interf.com",
   "engines": {

package/public-repo/CONTRIBUTING.md

@@ -2,29 +2,29 @@
 
 This public surface contains the files users and agent hosts need to inspect:
 the README, license and security docs, bundled Skills, plugin manifests, and
-public Method packages.
+public Build Plans.
 
 The Interf engine source is private. Do not add private source paths,
 maintainer docs, or internal repo instructions here.
 
 ## What To Change Here
 
-- Public product docs: `README.md`, `SECURITY.md`, `TRADEMARKS.md`.
+- Public product docs: the public README, `SECURITY.md`, and `TRADEMARKS.md`.
 - Agent Skills: `skills/interf/`.
 - Host plugin bundles: `plugins/`.
-- Public Method packages: `methods/`.
+- Public Build Plans: `build-plans/`.
 
-## Public Method Packages
+## Public Build Plans
 
-Method packages are inspectable folders. Keep them standalone:
+Build Plans are inspectable folders. Keep them standalone:
 
-- `method.json` declares the Build Plan stages and Artifact outputs.
-- `method.schema.json` declares the output contract.
-- `compile/stages/<stage>/SKILL.md` contains stage instructions.
-- `use/query/SKILL.md` tells agents how to read the portable context.
+- `build-plan.json` is the current technical filename for the Build Plan stages and Artifact outputs.
+- `build-plan.schema.json` is the current technical filename for the output contract.
+- `build/stages/<stage>/SKILL.md` contains stage instructions.
+- `use/query/SKILL.md` tells agents how to read the verifiable context.
 - `improve/SKILL.md` tells Interf how to revise the plan when checks fail.
 
-For the shipped default Method, edit `methods/interf-default/`.
+For the shipped default Build Plan, edit `build-plans/interf-default/`.
 
 ## Agent Skills And Plugins
 
@@ -36,12 +36,12 @@ Plugin bundles should stay thin:
 - copied Interf Skill when the host requires a local copy
 - MCP configuration that launches `interf mcp`
 
-The MCP server implementation ships inside `@interf/compiler`.
+The MCP server implementation ships inside `interf`.
 
 ## Before Opening A PR
 
 Check that public docs do not reference private paths such as internal source
 trees, maintainer-only docs, or local machine paths.
 
-If you changed a Method package, test it with an installed `@interf/compiler`
+If you changed a Build Plan, test it with an installed `interf`
 runtime before submitting the change.