@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/engine/runtime-resource-builders.d.ts

@@ -1,28 +1,28 @@
 /**
  * Pure shaping helpers used by the runtime to assemble resource payloads
- * (preparations, methods, proofs, log paths, readiness summaries) from
+ * (preparations, Build Plans, proof, log paths, readiness summaries) from
  * raw state/run records. No I/O, no `this` — every input is passed in.
  *
  * Splitting these out keeps the runtime coordinator focused on
  * orchestration rather than payload formatting.
  */
 import { type ArtifactRef, type ProofRecord } from "./execution/lib/schema.js";
-import { type CompiledState } from "./compile/state.js";
-import { type RuntimeRun } from "./compile/lib/schema.js";
+import { type VerifiableContextState } from "./build/state.js";
+import { type RuntimeRun } from "./build/lib/schema.js";
 import { type Artifact, type Readiness, type VerifyTargetResult } from "../contracts/lib/schema.js";
 import { type TestRunTargetSummary } from "./verify/lib/schema.js";
 import { type SourcePreparationConfig } from "../project/lib/schema.js";
-import { type MethodResource, type PreparationResource } from "./lib/schema.js";
-export declare function createRunId(prefix: "compile" | "verify" | "job"): string;
+import { type BuildPlanResource, type PreparationResource } from "./lib/schema.js";
+export declare function createRunId(prefix: "build" | "verify" | "job"): string;
 export declare function stageArtifactRefs(stageId: string, artifacts: string[] | undefined): ArtifactRef[];
 export declare function proofForStage(options: {
     runId: string;
     stageId: string;
     summary?: string | null;
-    stageState: NonNullable<CompiledState["stages"]>[string];
+    stageState: NonNullable<VerifiableContextState["stages"]>[string];
     artifacts: ArtifactRef[];
 }): ProofRecord;
-export declare function logsForStageRun(stageState: NonNullable<CompiledState["stages"]>[string] | undefined): {
+export declare function logsForStageRun(stageState: NonNullable<VerifiableContextState["stages"]>[string] | undefined): {
     prompt_path: string;
     event_stream_path: string;
     status_path: string;
@@ -38,15 +38,20 @@ export declare function passRate(passed: number, total: number): number | null;
 export declare function readinessTargetResult(summary: TestRunTargetSummary | null | undefined, currentFingerprint: string | null, readinessRunFingerprint: string | null | undefined): VerifyTargetResult | null;
 export declare function readinessSummaryForStatus(status: Readiness["status"]): string;
 export declare function readinessStateToPreparationReadiness(readiness: Readiness): Readiness;
-export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: Readiness, latestCompileRunId: string | null, latestTestRunId: string | null, artifacts?: PreparationResource["artifacts"]): PreparationResource;
-export declare function buildMethodResource(resource: {
+export declare function buildPreparationResource(rootPath: string, preparation: SourcePreparationConfig, readiness: Readiness, latestBuildRunId: string | null, latestTestRunId: string | null, artifacts?: PreparationResource["artifacts"]): PreparationResource;
+export declare function buildBuildPlanResource(resource: {
     id: string;
     path: string;
     label?: string;
     hint?: string;
+    purpose?: {
+        label: string;
+        taskHint: string;
+    };
+    inputs?: BuildPlanResource["inputs"];
     source_kind: "builtin" | "local";
     built_in: boolean;
     active_for_preparations: string[];
     artifacts: Artifact[];
-    stages: MethodResource["stages"];
-}): MethodResource;
+    stages: BuildPlanResource["stages"];
+}): BuildPlanResource;

package/dist/packages/engine/runtime-resource-builders.js

@@ -1,6 +1,6 @@
 import { ReadinessSchema, } from "../contracts/lib/schema.js";
-import { methodIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project/source-config.js";
-import { MethodResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
+import { buildPlanIdForSourcePreparationConfig, resolveSourcePreparationPath, } from "../project/source-config.js";
+import { BuildPlanResourceSchema, PreparationResourceSchema, } from "./lib/schema.js";
 export function createRunId(prefix) {
     return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -85,19 +85,19 @@ export function readinessSummaryForStatus(status) {
     if (status === "ready")
         return "Ready for agent work.";
     if (status === "not-ready")
-        return "Readiness checks did not pass.";
+        return "Artifact or readiness checks did not pass.";
     if (status === "stale")
         return "Readiness checks are stale for the current saved checks.";
     if (status === "checking")
         return "Readiness checks are running.";
     if (status === "building")
-        return "Portable context is building.";
+        return "Verifiable context is building.";
     if (status === "built")
-        return "Portable context is built; readiness has not been proven yet.";
+        return "Verifiable context is built; readiness has not been proven yet.";
     if (status === "not-built")
-        return "Portable context has not been built yet.";
+        return "Verifiable context has not been built yet.";
     if (status === "not-configured")
-        return "No readiness checks are configured.";
+        return "No checks are configured.";
     return "Latest preparation failed.";
 }
 export function readinessStateToPreparationReadiness(readiness) {
@@ -106,41 +106,52 @@ export function readinessStateToPreparationReadiness(readiness) {
         checks: readiness.checks.map((check) => ({ ...check })),
     });
 }
-export function buildPreparationResource(rootPath, preparation, readiness, latestCompileRunId, latestTestRunId, artifacts = []) {
-    const methodId = methodIdForSourcePreparationConfig(preparation);
+export function buildPreparationResource(rootPath, preparation, readiness, latestBuildRunId, latestTestRunId, artifacts = []) {
+    const buildPlanId = buildPlanIdForSourcePreparationConfig(preparation);
     return PreparationResourceSchema.parse({
         id: preparation.name,
         name: preparation.name,
         preparation,
         source_path: resolveSourcePreparationPath(rootPath, preparation),
-        method_id: methodId,
+        build_plan_id: buildPlanId,
         checks: preparation.checks,
-        portable_context: {
+        requested_artifacts: preparation.requested_artifacts ?? [],
+        source_profile: preparation.source_profile ?? null,
+        verifiable_context: {
             preparation: preparation.name,
-            path: readiness.portable_context_path,
-            exists: readiness.portable_context_path !== null,
-            method_id: methodId,
-            latest_compile_run_id: latestCompileRunId,
+            path: readiness.verifiable_context_path,
+            exists: readiness.verifiable_context_path !== null,
+            build_plan_id: buildPlanId,
+            latest_build_run_id: latestBuildRunId,
             latest_test_run_id: latestTestRunId,
         },
-        portable_context_path: readiness.portable_context_path,
+        verifiable_context_path: readiness.verifiable_context_path,
         readiness: readinessStateToPreparationReadiness(readiness),
         runs: {
-            latest_compile_run_id: latestCompileRunId,
+            latest_build_run_id: latestBuildRunId,
             latest_test_run_id: latestTestRunId,
         },
-        latest_compile_run_id: latestCompileRunId,
+        latest_build_run_id: latestBuildRunId,
         latest_test_run_id: latestTestRunId,
         artifacts,
     });
 }
-export function buildMethodResource(resource) {
-    return MethodResourceSchema.parse({
+export function buildBuildPlanResource(resource) {
+    return BuildPlanResourceSchema.parse({
         id: resource.id,
-        method_id: resource.id,
+        build_plan_id: resource.id,
         path: resource.path,
         ...(resource.label ? { label: resource.label } : {}),
         ...(resource.hint ? { hint: resource.hint } : {}),
+        ...(resource.purpose
+            ? {
+                purpose: {
+                    label: resource.purpose.label,
+                    task_hint: resource.purpose.taskHint,
+                },
+            }
+            : {}),
+        inputs: resource.inputs ?? [],
         source_kind: resource.source_kind,
         built_in: resource.built_in,
         active_for_preparations: resource.active_for_preparations,

package/dist/packages/engine/runtime.d.ts

@@ -1,21 +1,21 @@
-import { type ArtifactRef, type CompileRun, type InterfRunEvent, type ProofRecord } from "./execution/lib/schema.js";
+import { type ArtifactRef, type BuildRun, type InterfRunEvent, type ProofRecord } from "./execution/lib/schema.js";
 import { type RunEventSink } from "./execution/events.js";
 import { type Readiness } from "../contracts/lib/schema.js";
 import type { SourcePreparationConfig } from "../project/lib/schema.js";
-import { type BillingEventSink } from "./compile/billing-events.js";
+import { type BillingEventSink } from "./build/billing-events.js";
 import type { IdempotencyStore, RunLeaseStore, TokenValidator } from "./cloud-seams.js";
-import { type ActionProposalCreateRequest, type ActionProposalPlan, type ActionProposalResource, type CompileRunCreateRequest, type CompileRunResource, type MethodResource, type LocalServiceHealth, type LocalJobEvent, type LocalJobEventAppendRequest, type LocalExecutorStatus, type LocalJobRunResource, type LocalRunHandlerResult, type PortableContextResource, type PreparationResource, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type RunObservabilityResource, type ServiceRegistryWorkspace, type SourceFileResource, type WorkspaceFileResource, type VerifyRunCreateRequest, type VerifyRunResource, type MethodAuthoringCreateRequest, type MethodAuthoringResult, type MethodChangeResult, type PreparationChangeResult, type PreparationSetupResult, type ResetResult } from "./lib/schema.js";
-export interface LocalServiceCompileRunContext {
+import { type ActionProposalCreateRequest, type ActionProposalPlan, type ActionProposalResource, type BuildRunCreateRequest, type BuildRunResource, type BuildPlanResource, type LocalServiceHealth, type LocalJobEvent, type LocalJobEventAppendRequest, type LocalExecutorStatus, type LocalJobRunResource, type LocalRunHandlerResult, type VerifiableContextResource, type PreparationResource, type ReadinessCheckDraftCreateRequest, type ReadinessCheckDraftResult, type RunObservabilityResource, type SourceFileResource, type VerifyRunCreateRequest, type VerifyRunResource, type BuildPlanAuthoringCreateRequest, type BuildPlanAuthoringResult, type BuildPlanChangeResult, type PreparationChangeResult, type PreparationSetupResult, type ResetResult } from "./lib/schema.js";
+export interface LocalServiceBuildRunContext {
     runId: string;
     sourcePath: string;
-    compiledPath: string;
+    verifiableContextPath: string;
     preparationConfig: SourcePreparationConfig;
     events: RunEventSink;
 }
 export interface LocalServiceVerifyRunContext {
     runId: string;
     sourcePath: string;
-    compiledPath: string;
+    verifiableContextPath: string;
     preparationConfig: SourcePreparationConfig;
 }
 export interface LocalServiceJobRunContext {
@@ -29,7 +29,7 @@ export interface LocalServiceActionPlanningContext {
     preparationHealth: Array<{
         name: string;
         readiness_checks: number;
-        portable_context_ready: boolean;
+        verifiable_context_ready: boolean;
         can_check_readiness: boolean;
         recommended_next_actions: string[];
     }>;
@@ -42,10 +42,10 @@ export interface LocalServiceActionPlanningContext {
 }
 export interface LocalServiceRunHandlers {
     planActionProposal(request: ActionProposalCreateRequest, context: LocalServiceActionPlanningContext): Promise<ActionProposalPlan>;
-    createCompileRun(request: CompileRunCreateRequest, context: LocalServiceCompileRunContext): Promise<LocalRunHandlerResult>;
+    createBuildRun(request: BuildRunCreateRequest, context: LocalServiceBuildRunContext): Promise<LocalRunHandlerResult>;
     createVerifyRun(request: VerifyRunCreateRequest, context: LocalServiceVerifyRunContext): Promise<LocalRunHandlerResult>;
     createReadinessCheckDraft(request: ReadinessCheckDraftCreateRequest, context: LocalServiceJobRunContext): Promise<ReadinessCheckDraftResult>;
-    createMethodAuthoringRun(request: MethodAuthoringCreateRequest, context: LocalServiceJobRunContext): Promise<MethodAuthoringResult>;
+    createBuildPlanAuthoringRun(request: BuildPlanAuthoringCreateRequest, context: LocalServiceJobRunContext): Promise<BuildPlanAuthoringResult>;
 }
 export interface LocalServiceRuntimeOptions {
     rootPath: string;
@@ -80,7 +80,7 @@ export interface LocalServiceRuntimeOptions {
  * Per-preparation context tracked by the runtime. Multiple preparations can
  * be registered against one running service; each one owns its rootPath and
  * activity timestamps. Routes pass the preparation explicitly to every
- * runtime method that needs one, so there is no swap-state to manage.
+   * runtime operation that needs one, so there is no swap-state to manage.
  */
 export interface PreparationContext {
     rootPath: string;
@@ -96,8 +96,8 @@ export declare class LocalServiceRuntime {
     /**
      * The seed root path the runtime was constructed with. Used as a
      * non-preparation fallback when a preparation-independent route
-     * (methods, action proposals, runs listings) needs an anchor to load
-     * shared state (user-library methods, bundled methods, etc).
+     * (Build Plans, action proposals, runs listings) needs an anchor to load
+     * shared state (user-library Build Plans, bundled Build Plans, etc).
      */
     readonly rootPath: string;
     /**
@@ -112,8 +112,8 @@ export declare class LocalServiceRuntime {
     /** In-flight runs across all preparations. Used for `idle_for_seconds`. */
     private activeRunCount;
     /**
-     * Active compile-run cancellation handles, keyed by run id. Populated
-     * when a compile run is launched and cleared once the run reaches a
+     * Active Build run cancellation handles, keyed by run id. Populated
+     * when a Build run is launched and cleared once the run reaches a
      * terminal state. Each entry remembers where the persisted record lives
      * so cancel can mark it without re-resolving the Preparation.
      *
@@ -122,9 +122,9 @@ export declare class LocalServiceRuntime {
      * need a shared lease store so a replica can take over a run whose
      * owning replica died.
      */
-    private activeCompileRuns;
+    private activeBuildRuns;
     /**
-     * Idempotency-key cache for `POST /v1/compile-runs`. Outer key is the
+     * Idempotency-key cache for `POS../../build-runs`. Outer key is the
      * resolved preparation root; inner key is the client-supplied idempotency
      * value. Namespacing per preparation prevents key collisions across
      * tenants on the same engine (CSO finding: a malicious preparation could
@@ -138,17 +138,17 @@ export declare class LocalServiceRuntime {
      */
     private idempotencyKeyCache;
     /**
-     * Read-side caches. Polling clients (Compiler UI, CLI status loops)
+     * Read-side caches. Polling clients (Interf UI, CLI status loops)
      * hit list/get endpoints multiple times per second; without these,
      * every request re-walks the filesystem and re-parses every JSON
      * record through Zod. The runtime invalidates each cache on the
      * matching write path. See {@link runtime-caches} for design notes.
      */
-    private readonly compileRunCache;
+    private readonly buildRunCache;
     private readonly verifyRunCache;
     private readonly readinessCache;
     private readonly sourceFilesCache;
-    private readonly methodListingCache;
+    private readonly buildPlanListingCache;
     /**
      * 0.17 — sink for per-Artifact billing events. Set once at construction.
      * Lazy-defaults to a per-run JSONL writer when no override was injected.
@@ -213,14 +213,6 @@ export declare class LocalServiceRuntime {
      * actual request cadence.
      */
     touchPreparation(prepDataDir: string): void;
-    /**
-     * Snapshot of registered preparations for the registry / status output.
-     * Wire shape (`ServiceRegistryWorkspace`) keeps the legacy
-     * "workspace" name for backward compatibility with the public health
-     * response and `~/.interf/services.json`. Synthetic-workspace bridge
-     * code; do not rename without coordinating an API break.
-     */
-    registeredPreparationSnapshots(): ServiceRegistryWorkspace[];
     /** Seconds since the most recent preparation activity (0 if active). */
     idleForSeconds(): number;
     health(prepDataDir?: string): LocalServiceHealth;
@@ -233,9 +225,8 @@ export declare class LocalServiceRuntime {
     computePreparationReadiness(prepDataDir: string, preparation: SourcePreparationConfig): Readiness;
     private computePreparationReadinessUncached;
     listSourceFiles(prepDataDir: string, preparationName?: string | null): SourceFileResource[];
-    listWorkspaceFiles(prepDataDir: string): WorkspaceFileResource[];
-    listMethods(prepDataDir: string): MethodResource[];
-    getMethod(prepDataDir: string, methodId: string): MethodResource | null;
+    listBuildPlans(prepDataDir: string): BuildPlanResource[];
+    getBuildPlanResource(prepDataDir: string, buildPlanId: string): BuildPlanResource | null;
     listJobs(prepDataDir: string): LocalJobRunResource[];
     getJob(prepDataDir: string, runId: string): LocalJobRunResource | null;
     getJobEvents(prepDataDir: string, runId: string): LocalJobEvent[] | null;
@@ -275,37 +266,37 @@ export declare class LocalServiceRuntime {
     listRunObservability(prepDataDir: string): RunObservabilityResource[];
     getRunObservability(prepDataDir: string, runId: string): RunObservabilityResource | null;
     /**
-     * Method-scoped runs: every method-authoring or method-improvement job
-     * whose `method` matches `methodId`. Surfaced through
-     * `GET /v1/methods/<id>/runs` so Method Detail can show the full audit
-     * trail of authoring + improvement work for a Method.
+     * Build Plan Activity runs: every Build Plan draft or improvement job whose
+     * Build Plan id matches `buildPlanId`. Surfaced through
+     * `GET /v1/build-plans/<id>/runs` so Build Plan detail can show the full
+     * audit trail of authoring + improvement work.
      */
-    listMethodRuns(prepDataDir: string, methodId: string): RunObservabilityResource[];
+    listBuildPlanRuns(prepDataDir: string, buildPlanId: string): RunObservabilityResource[];
     private createJobRun;
     private appendJobRunEvent;
     createReadinessCheckDraftRun(prepDataDir: string, requestValue: unknown): Promise<LocalJobRunResource>;
-    applyMethodChange(prepDataDir: string, requestValue: unknown): MethodChangeResult;
+    applyBuildPlanChange(prepDataDir: string, requestValue: unknown): BuildPlanChangeResult;
     applyPreparationSetup(prepDataDir: string, requestValue: unknown): PreparationSetupResult;
     applyPreparationChange(prepDataDir: string, requestValue: unknown): PreparationChangeResult;
     applyReset(prepDataDir: string, requestValue: unknown): ResetResult;
-    createMethodAuthoringRun(prepDataDir: string, requestValue: unknown, jobType?: "method-authoring" | "method-improvement"): Promise<LocalJobRunResource>;
-    listPortableContexts(prepDataDir: string): PortableContextResource[];
-    getPortableContext(prepDataDir: string, preparationName: string): PortableContextResource | null;
-    listCompileRuns(prepDataDir: string): CompileRunResource[];
-    listCompileRunsForPreparation(prepDataDir: string, preparationName: string): CompileRun[];
-    getCompileRun(prepDataDir: string, runId: string): CompileRunResource | null;
-    getCompileRunEvents(prepDataDir: string, runId: string): InterfRunEvent[] | null;
-    getCompileRunProof(prepDataDir: string, runId: string): ProofRecord[] | null;
-    getCompileRunArtifacts(prepDataDir: string, runId: string): ArtifactRef[] | null;
-    createCompileRun(prepDataDir: string, requestValue: unknown): Promise<CompileRunResource>;
+    createBuildPlanAuthoringRun(prepDataDir: string, requestValue: unknown, jobType?: "build-plan-draft" | "build-plan-improvement"): Promise<LocalJobRunResource>;
+    listVerifiableContexts(prepDataDir: string): VerifiableContextResource[];
+    getVerifiableContext(prepDataDir: string, preparationName: string): VerifiableContextResource | null;
+    listBuildRuns(prepDataDir: string): BuildRunResource[];
+    listBuildRunsForPreparation(prepDataDir: string, preparationName: string): BuildRun[];
+    getBuildRun(prepDataDir: string, runId: string): BuildRunResource | null;
+    getBuildRunEvents(prepDataDir: string, runId: string): InterfRunEvent[] | null;
+    getBuildRunProof(prepDataDir: string, runId: string): ProofRecord[] | null;
+    getBuildRunArtifacts(prepDataDir: string, runId: string): ArtifactRef[] | null;
+    createBuildRun(prepDataDir: string, requestValue: unknown): Promise<BuildRunResource>;
     /**
-     * Cancel an in-flight compile run. Marks the persisted record as
+     * Cancel an in-flight Build run. Marks the persisted record as
      * `cancelled`, emits a `run.cancelled` event to capture the cancellation in
      * the run timeline, and clears the active handle so retries may start a
      * fresh run. If the run already finished, returns
      * `{ cancelled: false, reason: "already finished" }` and persists nothing.
      */
-    cancelCompileRun(runId: string): {
+    cancelBuildRun(runId: string): {
         cancelled: boolean;
         reason?: string;
     };
@@ -315,7 +306,7 @@ export declare class LocalServiceRuntime {
      * elapsed. The preparation argument is required so that the same key in
      * two different preparations always returns two different runs.
      */
-    findIdempotentCompileRun(prepDataDir: string, key: string): string | null;
+    findIdempotentBuildRun(prepDataDir: string, key: string): string | null;
     /**
      * Cache the run id created (or returned) for this idempotency key in
      * `prepDataDir`. Entries expire after `IDEMPOTENCY_TTL_MS`. Pruning
@@ -323,7 +314,7 @@ export declare class LocalServiceRuntime {
      * every read AND write, which was O(N) per request. Now we only sweep
      * when the cache grows past {@link IDEMPOTENCY_PRUNE_THRESHOLD}.
      */
-    recordIdempotentCompileRun(prepDataDir: string, key: string, runId: string): void;
+    recordIdempotentBuildRun(prepDataDir: string, key: string, runId: string): void;
     /** Total cached idempotency entries across all preparations. */
     private totalIdempotencyEntries;
     private pruneIdempotencyKeyCache;
@@ -339,12 +330,12 @@ export declare class LocalServiceRuntime {
     listVerifyRunsForPreparation(prepDataDir: string, preparationName: string): VerifyRunResource[];
     getVerifyRun(prepDataDir: string, runId: string): VerifyRunResource | null;
     createVerifyRun(prepDataDir: string, requestValue: unknown): Promise<VerifyRunResource>;
-    private runCompileInBackground;
+    private runBuildInBackground;
     private runTestInBackground;
     private runReadinessCheckDraftInBackground;
     private runReadinessCheckDraftInBackgroundInner;
-    private runMethodAuthoringInBackground;
-    private runMethodAuthoringInBackgroundInner;
+    private runBuildPlanAuthoringInBackground;
+    private runBuildPlanAuthoringInBackgroundInner;
     private jobRunContext;
     private defaultPreparationName;
     private planActionProposal;
@@ -352,23 +343,25 @@ export declare class LocalServiceRuntime {
     private buildActionProposal;
     private submitActionProposal;
     private resolvePreparationConfig;
-    private ensureCompiledForRun;
-    private readCompileRun;
-    private finalizeInterruptedCompileRuns;
+    private ensureVerifiableContextForRun;
+    private readBuildRun;
+    private hydrateBuildRunFromRuntime;
+    private finalizeInterruptedBuildRuns;
+    private finalizeInterruptedJobRuns;
     /**
-     * 0.17 — emit per-Artifact billing events when a compile run reaches
+     * 0.17 — emit per-Artifact billing events when a Build run reaches
      * a terminal state. STUB FORM: writes a JSONL file alongside the run
      * record by default. Production sink (Metronome HTTP) wires in 0.18+.
      * The JSONL output is observability/dev fixture, NOT production
      * billing data.
      */
     private emitBillingEventsForRun;
-    private writeCompileRun;
+    private writeBuildRun;
     private writeJobRun;
     private writeActionProposal;
     private setJobRunResult;
-    private recordCompileRunEvent;
-    private refreshCompileRunFromRuntime;
+    private recordBuildRunEvent;
+    private refreshBuildRunFromRuntime;
     private emitRuntimeDerivedEvents;
     private readLatestReadinessRun;
     private checksEvaluatedEvent;