@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/engine/preparation-store.d.ts

@@ -1,25 +1,24 @@
 /**
  * 0.13 preparation store.
  *
- * Each preparation lives at `~/.interf/preparations/<id>/` and is also
- * registered with the runtime as a synthetic workspace so the existing
- * compile / test / readiness machinery (preparation-keyed under the hood)
- * keeps working without a parallel implementation.
+ * Each preparation lives at `~/.interf/preparations/<id>/` and is registered
+ * with the runtime so the build / test / readiness machinery can find its
+ * preparation data dir.
  *
  *   ~/.interf/preparations/<id>/
  *     interf.json          ← preparation config, single preparation entry name=<id>
- *     <id>/                ← portable context (matches preparation name)
+ *     <id>/                ← verifiable context (matches preparation name)
  *
  * NOTE: We keep the synthetic `interf.json` shape (with a `preparations[]`
- * array of length 1, name=id, path=id) so the existing compile/test
+ * array of length 1, name=id, path=id) so the existing build/test
  * machinery stays functional. The doc-shape `config.json` /
- * `portable-context/` from `instance-paths.ts` is aspirational; transitioning
- * the entire compile pipeline to read those names is out of scope for the
+ * `verifiable-context/` from `instance-paths.ts` is aspirational; transitioning
+ * the entire build pipeline to read those names is out of scope for the
  * 0.13 cutover.
  *
  * Public callers reach this through the preparation-keyed HTTP routes.
  */
-import type { SourcePreparationConfig } from "../project/lib/schema.js";
+import type { RequestedArtifact, SourcePreparationConfig, SourceProfile, SourceReadinessCheck } from "../project/lib/schema.js";
 import type { LocalServiceRuntime } from "./runtime.js";
 export interface PreparationCreateInput {
     id: string;
@@ -27,27 +26,21 @@ export interface PreparationCreateInput {
         kind: "local-folder";
         locator: string;
     };
-    /** Method binding. Null/undefined means "not bound yet" — bind later via update. */
-    method_id?: string | null;
+    /** Build Plan binding. Null/undefined means "not bound yet" — bind later via update. */
+    build_plan_id?: string | null;
     about?: string;
-    checks?: Array<{
-        question: string;
-        answer?: string;
-        strictness?: string;
-        expect?: string;
-    }>;
+    requested_artifacts?: RequestedArtifact[];
+    source_profile?: SourceProfile;
+    checks?: SourceReadinessCheck[];
     max_attempts?: number;
     max_loops?: number;
 }
 export interface PreparationUpdateInput {
-    method_id?: string | null;
+    build_plan_id?: string | null;
     about?: string | null;
-    checks?: Array<{
-        question: string;
-        answer?: string;
-        strictness?: string;
-        expect?: string;
-    }>;
+    requested_artifacts?: RequestedArtifact[];
+    source_profile?: SourceProfile | null;
+    checks?: SourceReadinessCheck[];
 }
 export interface StoredPreparation {
     id: string;
@@ -56,11 +49,11 @@ export interface StoredPreparation {
         kind: "local-folder";
         locator: string;
     };
-    /** Null when no method has been bound to this preparation yet. */
-    methodId: string | null;
+    /** Null when no Build Plan has been bound to this preparation yet. */
+    buildPlanId: string | null;
     about: string | null;
     config: SourcePreparationConfig;
-    portableContextPath: string;
+    verifiableContextPath: string;
     configPath: string;
 }
 /** List every preparation registered under `~/.interf/preparations/`. */
@@ -68,28 +61,28 @@ export declare function listStoredPreparations(): StoredPreparation[];
 /** Read one preparation by id. Returns null when missing. */
 export declare function getStoredPreparation(prepId: string): StoredPreparation | null;
 /**
- * Create a preparation: scaffold its data dir, write the synthetic
- * workspace config, and register it with the runtime so subsequent
- * compile / test / readiness calls find it.
+ * Create a preparation: scaffold its data dir, write the local
+ * Preparation config, and register it with the runtime so subsequent
+ * build / test / readiness calls find it.
  *
- * Throws on validation errors (bad id, bad method id, source missing).
+ * Throws on validation errors (bad id, bad Build Plan id, source missing).
  */
 export declare function createStoredPreparation(runtime: LocalServiceRuntime, input: PreparationCreateInput): StoredPreparation;
 /**
- * Delete a preparation: deregister its synthetic workspace and remove
+ * Delete a preparation: deregister its runtime context and remove
  * `~/.interf/preparations/<id>/` from disk. Returns true when something
  * was actually removed.
  */
 export declare function deleteStoredPreparation(runtime: LocalServiceRuntime, prepId: string): boolean;
 /**
- * Update mutable fields on an existing preparation (method binding,
+ * Update mutable fields on an existing preparation (Build Plan binding,
  * about text). Returns the freshly-loaded record. Throws if the
  * preparation does not exist.
  */
 export declare function updateStoredPreparation(prepId: string, patch: PreparationUpdateInput): StoredPreparation;
 /**
  * Re-register every preparation directory with the runtime on startup so
- * synthetic workspaces survive a `interf web` restart.
+ * preparations survive a `interf web` restart.
  */
 export declare function rehydratePreparations(runtime: LocalServiceRuntime): void;
 /** Build the wire shape for `GET /v1/preparations/<id>` given a stored preparation. */
@@ -99,12 +92,14 @@ export declare function preparationWireShape(stored: StoredPreparation): {
         kind: string;
         locator: string;
     };
-    method_id: string | null;
+    build_plan_id: string | null;
     about: string | null;
     config_path: string;
-    portable_context: {
+    verifiable_context: {
         kind: "local-path";
         value: string;
     };
     checks: SourcePreparationConfig["checks"];
+    requested_artifacts: SourcePreparationConfig["requested_artifacts"];
+    source_profile: SourcePreparationConfig["source_profile"] | null;
 };

package/dist/packages/engine/preparation-store.js

@@ -1,27 +1,26 @@
 /**
  * 0.13 preparation store.
  *
- * Each preparation lives at `~/.interf/preparations/<id>/` and is also
- * registered with the runtime as a synthetic workspace so the existing
- * compile / test / readiness machinery (preparation-keyed under the hood)
- * keeps working without a parallel implementation.
+ * Each preparation lives at `~/.interf/preparations/<id>/` and is registered
+ * with the runtime so the build / test / readiness machinery can find its
+ * preparation data dir.
  *
  *   ~/.interf/preparations/<id>/
  *     interf.json          ← preparation config, single preparation entry name=<id>
- *     <id>/                ← portable context (matches preparation name)
+ *     <id>/                ← verifiable context (matches preparation name)
  *
  * NOTE: We keep the synthetic `interf.json` shape (with a `preparations[]`
- * array of length 1, name=id, path=id) so the existing compile/test
+ * array of length 1, name=id, path=id) so the existing build/test
  * machinery stays functional. The doc-shape `config.json` /
- * `portable-context/` from `instance-paths.ts` is aspirational; transitioning
- * the entire compile pipeline to read those names is out of scope for the
+ * `verifiable-context/` from `instance-paths.ts` is aspirational; transitioning
+ * the entire build pipeline to read those names is out of scope for the
  * 0.13 cutover.
  *
  * Public callers reach this through the preparation-keyed HTTP routes.
  */
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
-import { PreparationNameSchema, MethodIdSchema, } from "../contracts/lib/schema.js";
+import { PreparationNameSchema, BuildPlanIdSchema, } from "../contracts/lib/schema.js";
 import { preparationDataDir, preparationsRoot, } from "./instance-paths.js";
 import { saveSourceFolderConfig, loadSourceFolderConfig, } from "../project/source-config.js";
 function ensurePreparationsRoot() {
@@ -44,10 +43,10 @@ function loadStoredPreparation(prepId) {
         id: prepId,
         prepDataDir,
         source: { kind: "local-folder", locator: sourceFolderPath },
-        methodId: preparation.method ?? null,
+        buildPlanId: preparation.build_plan ?? null,
         about: preparation.about ?? null,
         config: preparation,
-        portableContextPath: join(prepDataDir, prepId),
+        verifiableContextPath: join(prepDataDir, prepId),
         configPath: join(prepDataDir, "interf.json"),
     };
 }
@@ -72,16 +71,16 @@ export function getStoredPreparation(prepId) {
     return loadStoredPreparation(prepId);
 }
 /**
- * Create a preparation: scaffold its data dir, write the synthetic
- * workspace config, and register it with the runtime so subsequent
- * compile / test / readiness calls find it.
+ * Create a preparation: scaffold its data dir, write the local
+ * Preparation config, and register it with the runtime so subsequent
+ * build / test / readiness calls find it.
  *
- * Throws on validation errors (bad id, bad method id, source missing).
+ * Throws on validation errors (bad id, bad Build Plan id, source missing).
  */
 export function createStoredPreparation(runtime, input) {
     PreparationNameSchema.parse(input.id);
-    if (input.method_id != null) {
-        MethodIdSchema.parse(input.method_id);
+    if (input.build_plan_id != null) {
+        BuildPlanIdSchema.parse(input.build_plan_id);
     }
     const sourceLocator = resolve(input.source.locator);
     if (!existsSync(sourceLocator)) {
@@ -99,13 +98,15 @@ export function createStoredPreparation(runtime, input) {
     const preparation = {
         name: input.id,
         path: input.id,
-        ...(input.method_id ? { method: input.method_id } : {}),
+        ...(input.build_plan_id ? { build_plan: input.build_plan_id } : {}),
         checks: (input.checks ?? []).map((check) => ({
             question: check.question,
             ...(check.answer ? { answer: check.answer } : {}),
             ...(check.strictness ? { strictness: check.strictness } : {}),
             ...(check.expect ? { expect: check.expect } : {}),
         })),
+        ...(input.requested_artifacts ? { requested_artifacts: input.requested_artifacts } : {}),
+        ...(input.source_profile ? { source_profile: input.source_profile } : {}),
         ...(input.about ? { about: input.about } : {}),
         ...(input.max_attempts ? { max_attempts: input.max_attempts } : {}),
         ...(input.max_loops ? { max_loops: input.max_loops } : {}),
@@ -114,8 +115,8 @@ export function createStoredPreparation(runtime, input) {
         source_folder: { path: sourceLocator },
         preparations: [preparation],
     });
-    // Hand the synthetic workspace to the runtime so the existing
-    // compile/test/readiness paths see it.
+    // Hand the Preparation data dir to the runtime so the existing
+    // build/test/readiness paths see it.
     runtime.registerPreparation(prepDataDir);
     const stored = loadStoredPreparation(input.id);
     if (!stored)
@@ -123,7 +124,7 @@ export function createStoredPreparation(runtime, input) {
     return stored;
 }
 /**
- * Delete a preparation: deregister its synthetic workspace and remove
+ * Delete a preparation: deregister its runtime context and remove
  * `~/.interf/preparations/<id>/` from disk. Returns true when something
  * was actually removed.
  */
@@ -136,7 +137,7 @@ export function deleteStoredPreparation(runtime, prepId) {
     return true;
 }
 /**
- * Update mutable fields on an existing preparation (method binding,
+ * Update mutable fields on an existing preparation (Build Plan binding,
  * about text). Returns the freshly-loaded record. Throws if the
  * preparation does not exist.
  */
@@ -144,15 +145,15 @@ export function updateStoredPreparation(prepId, patch) {
     const stored = loadStoredPreparation(prepId);
     if (!stored)
         throw new Error(`Preparation not found: ${prepId}`);
-    if (patch.method_id !== undefined && patch.method_id !== null) {
-        MethodIdSchema.parse(patch.method_id);
+    if (patch.build_plan_id !== undefined && patch.build_plan_id !== null) {
+        BuildPlanIdSchema.parse(patch.build_plan_id);
     }
     const nextPreparation = {
         ...stored.config,
-        ...(patch.method_id === null
-            ? { method: undefined }
-            : patch.method_id !== undefined
-                ? { method: patch.method_id }
+        ...(patch.build_plan_id === null
+            ? { build_plan: undefined }
+            : patch.build_plan_id !== undefined
+                ? { build_plan: patch.build_plan_id }
                 : {}),
         ...(patch.checks !== undefined
             ? { checks: patch.checks.map((check) => ({
@@ -162,6 +163,14 @@ export function updateStoredPreparation(prepId, patch) {
                     ...(check.expect ? { expect: check.expect } : {}),
                 })) }
             : {}),
+        ...(patch.requested_artifacts !== undefined
+            ? { requested_artifacts: patch.requested_artifacts }
+            : {}),
+        ...(patch.source_profile === null
+            ? { source_profile: undefined }
+            : patch.source_profile !== undefined
+                ? { source_profile: patch.source_profile }
+                : {}),
     };
     const aboutPatch = patch.about === undefined ? stored.about : patch.about;
     const preparationWithAbout = aboutPatch
@@ -181,7 +190,7 @@ export function updateStoredPreparation(prepId, patch) {
 }
 /**
  * Re-register every preparation directory with the runtime on startup so
- * synthetic workspaces survive a `interf web` restart.
+ * preparations survive a `interf web` restart.
  */
 export function rehydratePreparations(runtime) {
     for (const stored of listStoredPreparations()) {
@@ -193,10 +202,12 @@ export function preparationWireShape(stored) {
     return {
         id: stored.id,
         source: stored.source,
-        method_id: stored.methodId,
+        build_plan_id: stored.buildPlanId,
         about: stored.about,
         config_path: stored.configPath,
-        portable_context: { kind: "local-path", value: stored.portableContextPath },
+        verifiable_context: { kind: "local-path", value: stored.verifiableContextPath },
         checks: stored.config.checks ?? [],
+        requested_artifacts: stored.config.requested_artifacts ?? [],
+        source_profile: stored.config.source_profile ?? null,
     };
 }

package/dist/packages/engine/readiness-check-draft.d.ts

@@ -1,4 +1,4 @@
-import type { MethodExecutor } from "./agents/lib/executors.js";
+import type { AgentExecutor } from "./agents/lib/executors.js";
 import type { SourceReadinessCheck } from "../project/lib/schema.js";
 export declare function buildReadinessCheckDraftPrompt(options: {
     preparationName: string;
@@ -11,7 +11,7 @@ export declare function draftReadinessChecks(options: {
     preparationName: string;
     sourceFolderPath: string;
     about?: string;
-    executor: MethodExecutor;
+    executor: AgentExecutor;
     targetCount?: number;
     onStatus?: (line: string) => void;
 }): Promise<{

package/dist/packages/engine/readiness-check-draft.js

@@ -21,7 +21,7 @@ export function buildReadinessCheckDraftPrompt(options) {
         ];
     return [
         "You are drafting Interf readiness checks for a local Source Folder.",
-        "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
+        "Read the files in this folder and draft a small set of checks that a human can verify from the source files.",
         "Do not ask follow-up questions.",
         "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the files in this Source Folder.",
         "",

package/dist/packages/engine/requested-artifacts.d.ts

@@ -0,0 +1,5 @@
+import type { RequestedArtifact } from "../project/lib/schema.js";
+import type { BuildPlanAuthoringArtifactRequirement } from "./lib/schema.js";
+export declare function requestedArtifactCheckLabel(check: RequestedArtifact["checks"][number]): string;
+export declare function formatRequestedArtifactsForPrompt(artifacts: RequestedArtifact[]): string;
+export declare function artifactRequirementsFromRequestedArtifacts(artifacts: RequestedArtifact[]): BuildPlanAuthoringArtifactRequirement[];

package/dist/packages/engine/requested-artifacts.js

@@ -0,0 +1,36 @@
+import { ArtifactIdSchema } from "../contracts/lib/schema.js";
+export function requestedArtifactCheckLabel(check) {
+    return typeof check === "string" ? check : check.label;
+}
+export function formatRequestedArtifactsForPrompt(artifacts) {
+    if (artifacts.length === 0)
+        return "";
+    return artifacts.map((artifact, index) => {
+        const lines = [
+            `${index + 1}. ${artifact.title}`,
+            artifact.purpose ?? artifact.description ?? null,
+            artifact.checks.length > 0
+                ? `Checks:\n${artifact.checks.map((check) => `- ${requestedArtifactCheckLabel(check)}`).join("\n")}`
+                : null,
+        ].filter((line) => Boolean(line));
+        return lines.join("\n");
+    }).join("\n\n");
+}
+export function artifactRequirementsFromRequestedArtifacts(artifacts) {
+    return artifacts.flatMap((artifact) => {
+        if (!artifact.id || !artifact.output?.shape)
+            return [];
+        const id = ArtifactIdSchema.safeParse(artifact.id);
+        if (!id.success)
+            return [];
+        return [{
+                id: id.data,
+                ...(artifact.description ?? artifact.purpose
+                    ? { description: artifact.description ?? artifact.purpose }
+                    : {}),
+                shape: artifact.output.shape,
+                checks: artifact.output.checks ?? [],
+                ...(artifact.output.stage_hint ? { stage_hint: artifact.output.stage_hint } : {}),
+            }];
+    });
+}

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

@@ -6,7 +6,8 @@ export declare const LOCAL_SERVICE_ROUTES: {
     readonly health: "/health";
     readonly instance: "/v1/instance";
     readonly preparations: "/v1/preparations";
-    readonly methods: "/v1/methods";
+    readonly buildPlans: "/v1/build-plans";
+    readonly buildRuns: "/v1/build-runs";
     readonly runs: "/v1/runs";
     readonly actionProposals: "/v1/action-proposals";
     /**
@@ -24,38 +25,38 @@ export declare const LOCAL_SERVICE_ROUTES: {
 };
 /** Preparation-scoped sub-resources (relative to /v1/preparations/<id>/). */
 export declare const PREPARATION_SUBRESOURCES: {
-    readonly compileRuns: "compile-runs";
+    readonly buildRuns: "build-runs";
     readonly verifyRuns: "verify-runs";
-    readonly methodAuthoringRuns: "method-authoring-runs";
-    readonly methodImprovementRuns: "method-improvement-runs";
+    readonly buildPlanDraftRuns: "build-plan-draft-runs";
+    readonly buildPlanImprovementRuns: "build-plan-improvement-runs";
     readonly readinessCheckDrafts: "readiness-check-drafts";
     readonly changes: "changes";
     readonly reset: "reset";
     readonly runs: "runs";
     readonly readiness: "readiness";
     readonly sourceFiles: "source-files";
-    readonly portableContext: "portable-context";
+    readonly verifiableContext: "verifiable-context";
     /**
-     * 0.16 — read a portable-context file (read-only, path-guarded
-     * inside the prep's portable-context root). Used by the locator
+     * 0.16 — read a verifiable-context file (read-only, path-guarded
+     * inside the prep's verifiable-context root). Used by the locator
      * pattern's `api-served` kind:
      *   GET /v1/preparations/<id>/files/<relpath>
      */
     readonly files: "files";
     /**
      * 0.17 — per-Artifact detail. Returns the latest status, contributing
-     * stages, and proof refs for a Method-declared Artifact:
+     * stages, and proof refs for a Build Plan-declared Artifact:
      *   GET /v1/preparations/<id>/artifacts/<artifact-id>
      */
     readonly artifacts: "artifacts";
 };
-/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
-export declare const METHOD_SUBRESOURCES: {
+/** Build Plan activity sub-resources (relative to /v1/build-plans/<id>/). */
+export declare const BUILD_PLAN_SUBRESOURCES: {
     readonly runs: "runs";
     /**
-     * 0.16 — read a method package file (read-only, path-guarded inside
-     * the method root). Used by the locator pattern's `api-served` kind:
-     *   GET /v1/methods/<id>/files/<relpath>
+     * Read a Build Plan definition file (read-only, path-guarded inside
+     * the Build Plan root). Used by the locator pattern's `api-served` kind:
+     *   GET /v1/build-plans/<id>/files/<relpath>
      */
     readonly files: "files";
 };
@@ -78,7 +79,7 @@ export declare function preparationSubresourcePath(prepId: string, sub: keyof ty
 export declare function runResourcePath(runId: string): string;
 /** Path builder: /v1/runs/<run-id>/<subresource>. */
 export declare function runSubresourcePath(runId: string, sub: keyof typeof RUN_SUBRESOURCES): string;
-/** Path builder: /v1/methods/<id>. */
-export declare function methodResourcePath(methodId: string): string;
-/** Path builder: /v1/methods/<id>/<subresource>. */
-export declare function methodSubresourcePath(methodId: string, sub: keyof typeof METHOD_SUBRESOURCES): string;
+/** Path builder: /v1/build-plans/<id>. */
+export declare function buildPlanResourcePath(buildPlanId: string): string;
+/** Path builder: /v1/build-plans/<id>/<subresource>. */
+export declare function buildPlanSubresourcePath(buildPlanId: string, sub: keyof typeof BUILD_PLAN_SUBRESOURCES): string;

package/dist/packages/engine/routes.js

@@ -7,7 +7,8 @@ export const LOCAL_SERVICE_ROUTES = {
     // 0.13 surface — preparation-keyed.
     instance: "/v1/instance",
     preparations: "/v1/preparations",
-    methods: "/v1/methods",
+    buildPlans: "/v1/build-plans",
+    buildRuns: "/v1/build-runs",
     runs: "/v1/runs",
     actionProposals: "/v1/action-proposals",
     /**
@@ -25,38 +26,38 @@ export const LOCAL_SERVICE_ROUTES = {
 };
 /** Preparation-scoped sub-resources (relative to /v1/preparations/<id>/). */
 export const PREPARATION_SUBRESOURCES = {
-    compileRuns: "compile-runs",
+    buildRuns: "build-runs",
     verifyRuns: "verify-runs",
-    methodAuthoringRuns: "method-authoring-runs",
-    methodImprovementRuns: "method-improvement-runs",
+    buildPlanDraftRuns: "build-plan-draft-runs",
+    buildPlanImprovementRuns: "build-plan-improvement-runs",
     readinessCheckDrafts: "readiness-check-drafts",
     changes: "changes",
     reset: "reset",
     runs: "runs",
     readiness: "readiness",
     sourceFiles: "source-files",
-    portableContext: "portable-context",
+    verifiableContext: "verifiable-context",
     /**
-     * 0.16 — read a portable-context file (read-only, path-guarded
-     * inside the prep's portable-context root). Used by the locator
+     * 0.16 — read a verifiable-context file (read-only, path-guarded
+     * inside the prep's verifiable-context root). Used by the locator
      * pattern's `api-served` kind:
      *   GET /v1/preparations/<id>/files/<relpath>
      */
     files: "files",
     /**
      * 0.17 — per-Artifact detail. Returns the latest status, contributing
-     * stages, and proof refs for a Method-declared Artifact:
+     * stages, and proof refs for a Build Plan-declared Artifact:
      *   GET /v1/preparations/<id>/artifacts/<artifact-id>
      */
     artifacts: "artifacts",
 };
-/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
-export const METHOD_SUBRESOURCES = {
+/** Build Plan activity sub-resources (relative to /v1/build-plans/<id>/). */
+export const BUILD_PLAN_SUBRESOURCES = {
     runs: "runs",
     /**
-     * 0.16 — read a method package file (read-only, path-guarded inside
-     * the method root). Used by the locator pattern's `api-served` kind:
-     *   GET /v1/methods/<id>/files/<relpath>
+     * Read a Build Plan definition file (read-only, path-guarded inside
+     * the Build Plan root). Used by the locator pattern's `api-served` kind:
+     *   GET /v1/build-plans/<id>/files/<relpath>
      */
     files: "files",
 };
@@ -88,11 +89,11 @@ export function runResourcePath(runId) {
 export function runSubresourcePath(runId, sub) {
     return `${runResourcePath(runId)}/${RUN_SUBRESOURCES[sub]}`;
 }
-/** Path builder: /v1/methods/<id>. */
-export function methodResourcePath(methodId) {
-    return `${LOCAL_SERVICE_ROUTES.methods}/${encodeURIComponent(methodId)}`;
+/** Path builder: /v1/build-plans/<id>. */
+export function buildPlanResourcePath(buildPlanId) {
+    return `${LOCAL_SERVICE_ROUTES.buildPlans}/${encodeURIComponent(buildPlanId)}`;
 }
-/** Path builder: /v1/methods/<id>/<subresource>. */
-export function methodSubresourcePath(methodId, sub) {
-    return `${methodResourcePath(methodId)}/${METHOD_SUBRESOURCES[sub]}`;
+/** Path builder: /v1/build-plans/<id>/<subresource>. */
+export function buildPlanSubresourcePath(buildPlanId, sub) {
+    return `${buildPlanResourcePath(buildPlanId)}/${BUILD_PLAN_SUBRESOURCES[sub]}`;
 }

package/dist/packages/engine/run-observability.d.ts

@@ -1,6 +1,8 @@
-import { type ArtifactRef, type CompileRun } from "./execution/lib/schema.js";
-import { type LocalJobRunResource, type RunObservabilityResource, type VerifyRunResource } from "./lib/schema.js";
+import { type ArtifactRef, type BuildRun } from "./execution/lib/schema.js";
+import { type BuildRunResource, type LocalJobRunResource, type RunObservabilityResource, type VerifyRunResource } from "./lib/schema.js";
 export declare function uniqueArtifacts(artifacts: ArtifactRef[]): ArtifactRef[];
-export declare function compileRunToObservability(run: CompileRun): RunObservabilityResource;
+type BuildRunForObservability = BuildRun | BuildRunResource["run"];
+export declare function buildRunToObservability(run: BuildRunForObservability): RunObservabilityResource;
 export declare function verifyRunToObservability(run: VerifyRunResource): RunObservabilityResource;
 export declare function jobRunToObservability(job: LocalJobRunResource): RunObservabilityResource;
+export {};