@interf/compiler 0.22.0 → 0.33.0

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

@@ -0,0 +1,352 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { refreshContextGraphBootstrapGuidance } from "../runtime/agents/lib/context-graph-bootstrap.js";
+import { readInterfConfig, } from "./interf.js";
+import { seedContextGraphBuildPlanPackage } from "../build-plans/package/interf-build-plan-package.js";
+import { readJsonFileWithSchema } from "../contracts/utils/parse.js";
+import { getBuildPlan } from "../build-plans/package/build-plan-definitions.js";
+import { DEFAULT_BUILD_PLAN_ID, buildPlanIdForProjectConfig, } from "../build-plans/build-plan-resolution.js";
+import { SourceFolderConfigSchema, } from "./lib/schema.js";
+import { listTestSpecs, writeTestSpec, } from "../runtime/verify/verify-specs.js";
+import { slugify } from "../contracts/utils/naming.js";
+import { assertPathWithinRoot, isPathWithinRoot } from "../contracts/utils/path-guards.js";
+import { defaultControlPathForContextGraph, resolveSourceControlPathForContextGraph, contextGraphInterfConfigPath, contextGraphInterfRoot, } from "../runtime/build/context-graph-paths.js";
+import { asProjectDataDir, projectConfigPath, PROJECT_CONFIG_FILENAME, } from "../contracts/lib/project-paths.js";
+export const SOURCE_FOLDER_CONFIG_PATH = PROJECT_CONFIG_FILENAME;
+export function sourceFolderConfigPath(projectDataDir) {
+    return projectConfigPath(asProjectDataDir(projectDataDir));
+}
+function readSourceFolderConfigFile(filePath) {
+    return readJsonFileWithSchema(filePath, "Source folder config", SourceFolderConfigSchema);
+}
+function normalizeBenchmarkChecks(cases) {
+    const seen = new Set();
+    return cases.map((caseSpec, index) => {
+        const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
+        let id = baseId;
+        let suffix = 2;
+        while (seen.has(id)) {
+            id = `${baseId}-${suffix}`;
+            suffix += 1;
+        }
+        seen.add(id);
+        return {
+            id,
+            question: caseSpec.question.trim(),
+            ...(caseSpec.answer ? { answer: caseSpec.answer.trim() } : {}),
+            ...(caseSpec.strictness ? { strictness: caseSpec.strictness.trim() } : {}),
+            ...(caseSpec.expect ? { expect: caseSpec.expect } : {}),
+        };
+    });
+}
+export function fingerprintBenchmarkChecks(checks) {
+    const normalized = checks.map((check) => ({
+        question: check.question.trim(),
+        ...(check.answer ? { answer: check.answer.trim() } : {}),
+        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
+        ...(check.expect ? { expect: check.expect } : {}),
+    }));
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 16);
+}
+export function loadSourceFolderConfig(projectDataDir) {
+    const filePath = sourceFolderConfigPath(projectDataDir);
+    if (!existsSync(filePath))
+        return null;
+    return readSourceFolderConfigFile(filePath);
+}
+export { DEFAULT_BUILD_PLAN_ID, buildPlanIdForProjectConfig } from "../build-plans/build-plan-resolution.js";
+function normalizeProjectConfig(projectConfig) {
+    const buildPlan = buildPlanIdForProjectConfig(projectConfig);
+    return {
+        ...projectConfig,
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
+    };
+}
+export function listProjectConfigs(config) {
+    return (config?.projects ?? []).map((project) => normalizeProjectConfig(project));
+}
+export function resolveBuildMaxAttempts(override = null) {
+    if (override == null)
+        return null;
+    const normalized = Math.trunc(override);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(5, normalized);
+}
+export function resolveBuildMaxLoops(override = null) {
+    if (override == null)
+        return null;
+    const normalized = Math.trunc(override);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(3, normalized);
+}
+export function getDefaultProjectConfig(config) {
+    const projects = listProjectConfigs(config);
+    return projects[0] ?? null;
+}
+export function findProjectConfig(config, projectId) {
+    return listProjectConfigs(config).find((project) => project.name === projectId) ?? null;
+}
+export function configuredSourceFolderPath(config) {
+    return config?.source_folder?.path ?? null;
+}
+export function resolveConfiguredSourceFolderPath(projectDataDir, config = loadSourceFolderConfig(projectDataDir)) {
+    const configuredPath = configuredSourceFolderPath(config);
+    return configuredPath ? resolve(projectDataDir, configuredPath) : null;
+}
+function toWritableSourceFolderConfig(config) {
+    const projects = config?.projects ?? [];
+    const sourceFolder = config?.source_folder;
+    if (projects.length > 0) {
+        return {
+            ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+            projects: projects.map((project) => toWritableProjectConfig(project)),
+        };
+    }
+    return {
+        ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+        projects: [],
+    };
+}
+function toWritableProjectConfig(project) {
+    const buildPlan = buildPlanIdForProjectConfig(project);
+    return {
+        name: project.name,
+        path: project.path,
+        ...(buildPlan ? { build_plan: buildPlan } : {}),
+        ...(project.latest_context_graph_run_id ? { latest_context_graph_run_id: project.latest_context_graph_run_id } : {}),
+    };
+}
+export function saveSourceFolderConfig(projectDataDir, config) {
+    const existing = loadSourceFolderConfig(projectDataDir);
+    const mergedConfig = {
+        ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
+        ...config,
+    };
+    mkdirSync(projectDataDir, { recursive: true });
+    writeFileSync(sourceFolderConfigPath(projectDataDir), JSON.stringify(toWritableSourceFolderConfig(mergedConfig), null, 2) + "\n");
+}
+export function upsertProjectConfig(projectDataDir, projectConfig, options = {}) {
+    const existing = loadSourceFolderConfig(projectDataDir);
+    const projects = listProjectConfigs(existing);
+    const candidateNames = Array.from(new Set([projectConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = projects.findIndex((entry) => candidateNames.includes(entry.name));
+    if (existingIndex >= 0) {
+        projects[existingIndex] = normalizeProjectConfig(projectConfig);
+    }
+    else {
+        projects.push(normalizeProjectConfig(projectConfig));
+    }
+    saveSourceFolderConfig(projectDataDir, {
+        projects: projects,
+    });
+}
+export function markProjectLatestContextGraphRun(projectDataDir, projectName, runId) {
+    const project = findProjectConfig(loadSourceFolderConfig(projectDataDir), projectName);
+    if (!project) {
+        throw new Error(`Project "${projectName}" is not saved in this control plane folder.`);
+    }
+    const next = {
+        ...project,
+        latest_context_graph_run_id: runId,
+    };
+    upsertProjectConfig(projectDataDir, next);
+    return next;
+}
+export function removeProjectConfig(projectDataDir, projectId) {
+    const existing = loadSourceFolderConfig(projectDataDir);
+    const projects = listProjectConfigs(existing);
+    const nextProjects = projects.filter((entry) => entry.name !== projectId);
+    if (nextProjects.length === projects.length)
+        return false;
+    saveSourceFolderConfig(projectDataDir, {
+        projects: nextProjects,
+    });
+    return true;
+}
+export function projectConfigFromInterfConfig(config, projectPath = `./${config.name}`) {
+    return {
+        name: config.name,
+        path: projectPath,
+        build_plan: config.build_plan,
+    };
+}
+export function loadContextGraphProjectConfig(contextGraphPath) {
+    const config = readInterfConfig(contextGraphPath);
+    if (!config)
+        return null;
+    const projectDataDir = resolveSourceControlPathForContextGraph(contextGraphPath);
+    const configuredProjects = listProjectConfigs(loadSourceFolderConfig(projectDataDir));
+    const defaultProjectPath = configuredProjects.length === 1
+        ? configuredProjects[0].path
+        : `./${config.name}`;
+    const sourceBinding = typeof config.source?.project_path === "string" && config.source.project_path.length > 0
+        ? config.source.project_path
+        : null;
+    const projectPath = sourceBinding
+        ? (() => {
+            const sourceAbsolutePath = resolve(contextGraphPath, sourceBinding);
+            if (!isPathWithinRoot(projectDataDir, sourceAbsolutePath)) {
+                return sourceAbsolutePath;
+            }
+            return relative(projectDataDir, sourceAbsolutePath).split(sep).join("/") || defaultProjectPath;
+        })()
+        : defaultProjectPath;
+    return projectConfigFromInterfConfig(config, projectPath);
+}
+export function saveContextGraphInterfConfig(contextGraphPath, config) {
+    mkdirSync(contextGraphInterfRoot(contextGraphPath), { recursive: true });
+    writeFileSync(contextGraphInterfConfigPath(contextGraphPath), JSON.stringify(config, null, 2) + "\n");
+    return config;
+}
+export function syncContextGraphInterfConfigFromProjectConfig(contextGraphPath, projectConfig) {
+    const current = readInterfConfig(contextGraphPath);
+    const projectDataDir = resolveSourceControlPathForContextGraph(contextGraphPath);
+    const projectSourceAbsolutePath = resolveProjectSourceBindingPath(projectDataDir, projectConfig);
+    const projectSourceRelativePath = relative(contextGraphPath, projectSourceAbsolutePath).split(sep).join("/") || ".";
+    const buildPlanId = buildPlanIdForProjectConfig(projectConfig)
+        ?? buildPlanIdForProjectConfig(current)
+        ?? DEFAULT_BUILD_PLAN_ID;
+    const buildPlanChanged = current?.build_plan !== undefined && current.build_plan !== buildPlanId;
+    const buildPlanOrigin = buildPlanChanged || !current?.build_plan_origin
+        ? {
+            selected: buildPlanId,
+            local_draft: false,
+        }
+        : current.build_plan_origin;
+    const nextConfig = {
+        ...(!current ? {
+            type: "context-graph",
+            source: {
+                path: projectSourceRelativePath,
+            },
+        } : {}),
+        type: "context-graph",
+        name: projectConfig.name,
+        build_plan: buildPlanId,
+        build_plan_origin: buildPlanOrigin,
+        source: {
+            path: projectSourceRelativePath,
+            control_path: defaultControlPathForContextGraph(contextGraphPath),
+            project_path: projectSourceRelativePath,
+        },
+    };
+    const saved = saveContextGraphInterfConfig(contextGraphPath, nextConfig);
+    if (buildPlanChanged) {
+        const selectedBuildPlan = getBuildPlan(buildPlanId, { projectDataDir });
+        seedContextGraphBuildPlanPackage({
+            contextGraphPath,
+            projectDataDir,
+            buildPlanId: selectedBuildPlan.id,
+        });
+    }
+    refreshContextGraphBootstrapGuidance(contextGraphPath);
+    return saved;
+}
+function selectSavedBenchmarkSpec(options) {
+    const specs = listTestSpecs(options.projectDataDir, options.targetType);
+    if (specs.length === 0)
+        return null;
+    if (options.targetName) {
+        return specs.find((spec) => spec.id === options.targetName ||
+            spec.name === options.targetName ||
+            spec.name === `${options.targetName} benchmark`) ?? null;
+    }
+    return specs.length === 1 ? specs[0] : null;
+}
+export function buildTestSpecFromSourceFolderConfig(options) {
+    const { projectDataDir, targetName, targetType = "context-graph" } = options;
+    return selectSavedBenchmarkSpec({ projectDataDir, targetName, targetType });
+}
+export function buildTestSpecFromProjectConfig(options) {
+    const { contextGraphPath, targetType = "context-graph" } = options;
+    const config = readInterfConfig(contextGraphPath);
+    if (!config)
+        return null;
+    return buildTestSpecFromSourceFolderConfig({
+        projectDataDir: resolveSourceControlPathForContextGraph(contextGraphPath),
+        targetName: config.name,
+        targetType,
+    });
+}
+export function writeBenchmarkSpecsForProject(options) {
+    if (options.checks.length === 0)
+        return {};
+    const baseSpec = {
+        id: options.projectName,
+        name: options.projectName,
+        description: options.description ?? `Saved benchmark checks for Project ${options.projectName}.`,
+        cases: normalizeBenchmarkChecks(options.checks),
+    };
+    return {
+        source_files: writeTestSpec(options.projectDataDir, { ...baseSpec, type: "source-files" }, { overwrite: true }),
+        context_graph: writeTestSpec(options.projectDataDir, { ...baseSpec, type: "context-graph" }, { overwrite: true }),
+    };
+}
+export function fingerprintTestSpec(spec) {
+    const normalized = spec.cases.map((testCase) => ({
+        question: testCase.question.trim(),
+        ...(testCase.file ? { file: testCase.file.trim() } : {}),
+        ...(testCase.answer ? { answer: testCase.answer.trim() } : {}),
+        ...(testCase.strictness ? { strictness: testCase.strictness.trim() } : {}),
+        ...(testCase.expect ? { expect: testCase.expect } : {}),
+    }));
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 16);
+}
+export function fingerprintSavedBenchmarkSpec(options) {
+    const spec = buildTestSpecFromSourceFolderConfig({
+        projectDataDir: options.projectDataDir,
+        targetName: options.projectName,
+        targetType: options.targetType ?? "context-graph",
+    });
+    return spec ? fingerprintTestSpec(spec) : null;
+}
+/**
+ * System path prefixes the runtime must never operate on, even when an
+ * absolute `project.path` was authored by hand. The schema-level
+ * refinement in `ProjectConfigSchema` is the primary line of
+ * defense; this is the in-process backstop for callers that hand-craft a
+ * ProjectConfig at runtime (e.g. Build Plan authoring helpers that
+ * construct a config from an InterfConfig).
+ */
+const FORBIDDEN_PROJECT_SOURCE_PATH_PREFIXES = [
+    "/etc",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/var/run",
+    "/var/lib",
+    "/usr",
+    "/bin",
+    "/sbin",
+    "/boot",
+];
+function rejectForbiddenProjectSourcePath(absolutePath) {
+    for (const prefix of FORBIDDEN_PROJECT_SOURCE_PATH_PREFIXES) {
+        if (absolutePath === prefix || absolutePath.startsWith(`${prefix}/`)) {
+            throw new Error(`Project Source path may not target system directory ${prefix}: ${absolutePath}`);
+        }
+    }
+}
+export function resolveProjectSourcePath(projectDataDir, projectConfig) {
+    const configuredPath = projectConfig.path.trim();
+    const resolvedPath = resolve(projectDataDir, configuredPath);
+    if (isAbsolute(configuredPath)) {
+        rejectForbiddenProjectSourcePath(resolvedPath);
+        return resolvedPath;
+    }
+    rejectForbiddenProjectSourcePath(resolvedPath);
+    return assertPathWithinRoot(projectDataDir, resolvedPath, "Source locator path");
+}
+export function resolveProjectSourceBindingPath(projectDataDir, projectConfig, config = loadSourceFolderConfig(projectDataDir)) {
+    return resolveConfiguredSourceFolderPath(projectDataDir, config)
+        ?? resolveProjectSourcePath(projectDataDir, projectConfig);
+}

package/dist/packages/projects/source-folders.d.ts

@@ -0,0 +1,11 @@
+export declare function listVisibleSourceFolders(projectDataDir: string): string[];
+export declare function isReservedProjectSourcePath(relativePath: string): boolean;
+export declare function normalizeProjectSourcePathForConfig(projectDataDir: string, value: string): string;
+export declare function defaultProjectIdForPath(sourceFolderPath: string): string;
+export declare function findSingleSourceFolderCandidate(projectDataDir: string): string | null;
+export declare function listSourceFolderChoices(projectDataDir?: string): Array<{
+    value: string;
+    label: string;
+    hint: string;
+}>;
+export declare function defaultProjectSourcePathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectDataDir?: string): string;

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

@@ -1,9 +1,9 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { slugify } from "../contracts/utils/naming.js";
-import { resolveSourcePreparationPath } from "./source-config.js";
+import { resolveProjectSourcePath } from "./source-config.js";
 import { isPathWithinRoot } from "../contracts/utils/path-guards.js";
-const DEFAULT_PREPARATION_NAME = "default";
+const DEFAULT_PROJECT_ID = "default";
 const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     ".DS_Store",
     ".git",
@@ -12,10 +12,10 @@ const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     "interf.json",
     "node_modules",
 ]);
-export function listVisibleSourceFolders(prepDataDir) {
+export function listVisibleSourceFolders(projectDataDir) {
     let rootEntries = [];
     try {
-        rootEntries = readdirSync(prepDataDir);
+        rootEntries = readdirSync(projectDataDir);
     }
     catch {
         return [];
@@ -24,7 +24,7 @@ export function listVisibleSourceFolders(prepDataDir) {
     const visibleDirectories = [];
     for (const entry of visibleEntries) {
         try {
-            const entryPath = join(prepDataDir, entry);
+            const entryPath = join(projectDataDir, entry);
             if (statSync(entryPath).isDirectory()) {
                 visibleDirectories.push(entry);
             }
@@ -35,64 +35,64 @@ export function listVisibleSourceFolders(prepDataDir) {
     }
     return visibleDirectories.sort((left, right) => left.localeCompare(right));
 }
-export function isReservedSourcePreparationPath(relativePath) {
+export function isReservedProjectSourcePath(relativePath) {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
     return normalized === "interf" ||
         normalized.startsWith("interf/") ||
         normalized === ".interf" ||
         normalized.startsWith(".interf/");
 }
-export function normalizeSourcePreparationPathForConfig(prepDataDir, value) {
+export function normalizeProjectSourcePathForConfig(projectDataDir, value) {
     const trimmedValue = value.trim();
-    const resolvedPath = resolveSourcePreparationPath(prepDataDir, { path: trimmedValue });
-    const relativePath = relative(prepDataDir, resolvedPath).split(sep).join("/") || ".";
+    const resolvedPath = resolveProjectSourcePath(projectDataDir, { path: trimmedValue });
+    const relativePath = relative(projectDataDir, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
-        throw new Error("Pick a Source Folder, not the Interf preparation data folder itself.");
+        throw new Error("Pick a Source Folder, not the Interf Project data folder itself.");
     }
-    if (isAbsolute(trimmedValue) && !isPathWithinRoot(prepDataDir, resolvedPath)) {
+    if (isAbsolute(trimmedValue) && !isPathWithinRoot(projectDataDir, resolvedPath)) {
         if (!existsSync(resolvedPath)) {
-            throw new Error("Pick an existing source folder.");
+            throw new Error("Pick an existing local Source folder.");
         }
         if (!statSync(resolvedPath).isDirectory()) {
-            throw new Error("Source folder must be a directory.");
+            throw new Error("Local Source folder must be a directory.");
         }
         return resolvedPath;
     }
-    if (isReservedSourcePreparationPath(relativePath)) {
-        throw new Error("Pick an existing source folder, not `interf/` or `.interf/`.");
+    if (isReservedProjectSourcePath(relativePath)) {
+        throw new Error("Pick an existing local Source folder, not `interf/` or `.interf/`.");
     }
     if (!existsSync(resolvedPath)) {
-        throw new Error("Pick an existing source folder.");
+        throw new Error("Pick an existing local Source folder.");
     }
     if (!statSync(resolvedPath).isDirectory()) {
-        throw new Error("Source folder must be a directory.");
+        throw new Error("Local Source folder must be a directory.");
     }
     return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
 }
-export function defaultPreparationNameForPath(sourceFolderPath) {
+export function defaultProjectIdForPath(sourceFolderPath) {
     const segments = sourceFolderPath
         .replace(/\\/g, "/")
         .replace(/\/+$/g, "")
         .split("/")
         .filter((segment) => segment.length > 0 && segment !== ".");
-    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_PREPARATION_NAME;
+    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_PROJECT_ID;
 }
-export function findSingleSourceFolderCandidate(prepDataDir) {
-    const visibleDirectories = listVisibleSourceFolders(prepDataDir);
+export function findSingleSourceFolderCandidate(projectDataDir) {
+    const visibleDirectories = listVisibleSourceFolders(projectDataDir);
     if (visibleDirectories.length !== 1) {
         return null;
     }
     return `./${visibleDirectories[0]}`;
 }
-export function listSourceFolderChoices(prepDataDir = process.cwd()) {
-    return listVisibleSourceFolders(prepDataDir).map((entry) => ({
+export function listSourceFolderChoices(projectDataDir = process.cwd()) {
+    return listVisibleSourceFolders(projectDataDir).map((entry) => ({
         value: `./${entry}`,
         label: entry,
         hint: `Use ./${entry} as the source folder`,
     }));
 }
-export function defaultSourcePreparationPathForPrompt(name, introStyle, prepDataDir = process.cwd()) {
-    const namedFolderPath = join(prepDataDir, name);
+export function defaultProjectSourcePathForPrompt(name, introStyle, projectDataDir = process.cwd()) {
+    const namedFolderPath = join(projectDataDir, name);
     if (existsSync(namedFolderPath)) {
         try {
             if (statSync(namedFolderPath).isDirectory()) {
@@ -104,7 +104,7 @@ export function defaultSourcePreparationPathForPrompt(name, introStyle, prepData
         }
     }
     if (introStyle === "first") {
-        return findSingleSourceFolderCandidate(prepDataDir) ?? `./${name}`;
+        return findSingleSourceFolderCandidate(projectDataDir) ?? `./${name}`;
     }
     return `./${name}`;
 }

package/dist/packages/{engine → runtime}/action-planner.d.ts

@@ -1,6 +1,6 @@
 import type { AgentExecutor } from "./agents/lib/executors.js";
 import type { LocalServiceActionPlanningContext } from "./runtime.js";
-import { type ActionProposalCreateRequest, type ActionProposalPlan } from "./lib/schema.js";
+import { type ActionProposalCreateRequest, type ActionProposalPlan } from "./schemas/index.js";
 export declare function buildActionPlannerPrompt(request: ActionProposalCreateRequest, context: LocalServiceActionPlanningContext, outputPath: string): string;
 export declare function planActionProposalWithExecutor(options: {
     request: ActionProposalCreateRequest;

package/dist/packages/{engine → runtime}/action-planner.js

@@ -1,9 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
-import { buildPlanIdForSourcePreparationConfig, } from "../build-plans/build-plan-resolution.js";
+import { buildPlanIdForProjectConfig, } from "../build-plans/build-plan-resolution.js";
 import { PACKAGE_ROOT } from "../build-plans/package/lib/package-root.js";
-import { asPreparationDataDir, preparationServiceActionPlansRoot, } from "../contracts/lib/preparation-paths.js";
-import { ActionProposalPlanSchema, } from "./lib/schema.js";
+import { asProjectDataDir, projectServiceActionPlansRoot, } from "../contracts/lib/project-paths.js";
+import { ActionProposalPlanSchema, } from "./schemas/index.js";
 function extractJsonObject(text) {
     try {
         return JSON.parse(text);
@@ -31,18 +31,16 @@ function readActionSkill() {
 }
 export function buildActionPlannerPrompt(request, context, outputPath) {
     const actionSkill = readActionSkill();
-    const preparations = context.preparations.map((preparation) => ({
-        name: preparation.name,
-        path: preparation.path,
-        about: preparation.about ?? null,
-        build_plan: buildPlanIdForSourcePreparationConfig(preparation),
-        checks: preparation.checks?.length ?? 0,
+    const projects = context.projects.map((project) => ({
+        name: project.name,
+        path: project.path,
+        build_plan: buildPlanIdForProjectConfig(project),
     }));
     const recentProposals = context.recentProposals.map((proposal) => ({
         status: proposal.status,
         action_type: proposal.action_type,
         title: proposal.title,
-        preparation: proposal.preparation ?? null,
+        project: proposal.project ?? null,
         request: proposal.request,
         command_preview: proposal.command_preview ?? null,
     }));
@@ -56,19 +54,19 @@ export function buildActionPlannerPrompt(request, context, outputPath) {
 User request:
 ${request.message}
 
-Selected Preparation hint: ${request.preparation ?? "(none)"}
+Selected Project hint: ${request.project ?? "(none)"}
 
 Structured request values:
 ${JSON.stringify(request.values ?? {}, null, 2)}
 
-Available Preparations:
-${JSON.stringify(preparations, null, 2)}
+Available Projects:
+${JSON.stringify(projects, null, 2)}
 
-Visible Source Folders:
+Visible Sources:
 ${JSON.stringify(sourceFolders, null, 2)}
 
 Action health:
-${JSON.stringify(context.preparationHealth, null, 2)}
+${JSON.stringify(context.projectHealth, null, 2)}
 
 Recent proposals, newest first. A short follow-up like "target source only" may be correcting the latest pending proposal:
 ${JSON.stringify(recentProposals, null, 2)}
@@ -77,7 +75,7 @@ Interf action skill source:
 ${actionSkill}
 
 Use the Interf action skill source as the authority for CLI semantics and Interf proposal mode. Preserve user intent over defaults.
-Use Action health to avoid proposing work that cannot run yet. If can_check_readiness is false, prefer the recommended next actions; do not propose a generic readiness check unless the user explicitly asks for a source-files-only baseline.
+Use Action health to avoid proposing work that cannot run yet. If can_run_benchmark is false, prefer the recommended next actions; benchmark targets need a built Context Graph with a recorded Source Manifest.
 If the user is asking a question or making casual conversation, return "clarification" with a helpful assistant_message. Do not invent a CLI command for non-action chat.
 If a field does not apply, omit it instead of writing null or an empty string.
 Do not run any CLI command. Do not edit files except the output JSON file.
@@ -87,8 +85,8 @@ ${outputPath}
 
 JSON schema:
 {
-  "action_type": "preparation-setup" | "preparation-change" | "build" | "test" | "readiness-check-draft" | "build-plan-draft" | "build-plan-change" | "build-plan-improvement" | "clarification",
-  "preparation": "Preparation id if applicable",
+  "action_type": "project-setup" | "project-change" | "build" | "benchmark" | "benchmark-question-draft" | "build-plan-draft" | "build-plan-change" | "build-plan-improvement" | "clarification",
+  "project": "Project id if applicable",
   "build_plan": "Build Plan id if applicable",
   "values": {},
   "title": "short approval card title",
@@ -99,7 +97,7 @@ JSON schema:
 `;
 }
 export async function planActionProposalWithExecutor(options) {
-    const planRoot = join(preparationServiceActionPlansRoot(asPreparationDataDir(options.context.sourcePath)), Date.now().toString(36));
+    const planRoot = join(projectServiceActionPlansRoot(asProjectDataDir(options.context.sourcePath)), Date.now().toString(36));
     mkdirSync(planRoot, { recursive: true });
     const outputPath = join(planRoot, "proposal.json");
     const prompt = buildActionPlannerPrompt(options.request, options.context, outputPath);
@@ -111,7 +109,7 @@ export async function planActionProposalWithExecutor(options) {
     if (exitCode !== 0 && !existsSync(outputPath)) {
         return ActionProposalPlanSchema.parse({
             action_type: "clarification",
-            preparation: options.request.preparation,
+            project: options.request.project,
             assistant_message: `${options.executor.displayName} could not create a safe Interf proposal.`,
         });
     }
@@ -121,8 +119,8 @@ export async function planActionProposalWithExecutor(options) {
     catch {
         return ActionProposalPlanSchema.parse({
             action_type: "clarification",
-            preparation: options.request.preparation,
-            assistant_message: "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Build Plan and I will prepare an approval proposal.",
+            project: options.request.project,
+            assistant_message: "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Project, build a Context Graph, benchmark, improve, or draft a Build Plan and I will prepare an approval proposal.",
         });
     }
 }

package/dist/packages/runtime/action-values.d.ts

@@ -0,0 +1 @@
+export { ActionValueIdPattern, ActionValueIdSchema, BuildPlanAuthoringActionValuesSchema, OptionalActionValueIdSchema, ProjectSetupActionValuesSchema, buildPlanAuthoringRequestFromActionValues, buildPlanAuthoringIntentBrief, projectSetupRequestFromActionValues, type BuildPlanAuthoringActionValues, type ProjectSetupActionValues, } from "./actions/index.js";

package/dist/packages/runtime/action-values.js

@@ -0,0 +1 @@
+export { ActionValueIdPattern, ActionValueIdSchema, BuildPlanAuthoringActionValuesSchema, OptionalActionValueIdSchema, ProjectSetupActionValuesSchema, buildPlanAuthoringRequestFromActionValues, buildPlanAuthoringIntentBrief, projectSetupRequestFromActionValues, } from "./actions/index.js";

package/dist/packages/runtime/actions/errors.d.ts

@@ -0,0 +1,2 @@
+import type { z } from "zod";
+export declare function packageSchemaFieldErrors(result: z.ZodSafeParseResult<unknown>, pathMap: Record<string, string>): Record<string, string>;

package/dist/packages/runtime/actions/errors.js

@@ -0,0 +1,12 @@
+export function packageSchemaFieldErrors(result, pathMap) {
+    if (result.success)
+        return {};
+    const errors = {};
+    for (const issue of result.error.issues) {
+        const path = issue.path.join(".");
+        const key = pathMap[path] ?? pathMap[issue.path.at(-1)?.toString() ?? ""] ?? "";
+        if (key && !errors[key])
+            errors[key] = issue.message;
+    }
+    return errors;
+}