@interf/compiler 0.18.0 → 0.22.0

package/dist/packages/build-plans/package/build-plan-review-paths.d.ts

@@ -0,0 +1,10 @@
+import type { BuildPlanImprovementContext } from "../../engine/build/lib/schema.js";
+export interface BuildPlanImprovementReviewSourcePaths {
+    verifiableContextRuntime: string | null;
+    readinessRuns: string | null;
+    executionShells: string | null;
+    targetTestRuns: string | null;
+    targetTestSandboxes: string | null;
+}
+export declare function resolveBuildPlanImprovementReviewSourcePaths(verifiableContextPath: string): BuildPlanImprovementReviewSourcePaths;
+export declare function resolveBuildPlanImprovementReviewPaths(verifiableContextPath: string): BuildPlanImprovementContext["review_paths"];

package/dist/packages/build-plans/package/build-plan-review-paths.js

@@ -0,0 +1,31 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { testRootForVerifiableContext, targetTestRunsRootForVerifiableContext, targetTestSandboxesRootForVerifiableContext, stageExecutionShellsRoot, verifiableContextRuntimeRoot, } from "../../engine/build/verifiable-context-paths.js";
+export function resolveBuildPlanImprovementReviewSourcePaths(verifiableContextPath) {
+    const verifiableContextRuntime = verifiableContextRuntimeRoot(verifiableContextPath);
+    const readinessRuns = testRootForVerifiableContext(verifiableContextPath);
+    const executionShells = stageExecutionShellsRoot(verifiableContextPath);
+    const targetTestRuns = targetTestRunsRootForVerifiableContext(verifiableContextPath);
+    const targetTestSandboxes = targetTestSandboxesRootForVerifiableContext(verifiableContextPath);
+    return {
+        verifiableContextRuntime: existsSync(verifiableContextRuntime) ? verifiableContextRuntime : null,
+        readinessRuns: existsSync(join(readinessRuns, "latest.json")) ||
+            existsSync(join(readinessRuns, "latest.md"))
+            ? readinessRuns
+            : null,
+        executionShells: existsSync(executionShells) ? executionShells : null,
+        targetTestRuns: existsSync(targetTestRuns) ? targetTestRuns : null,
+        targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,
+    };
+}
+export function resolveBuildPlanImprovementReviewPaths(verifiableContextPath) {
+    const sources = resolveBuildPlanImprovementReviewSourcePaths(verifiableContextPath);
+    return {
+        build_plan_root: "build-plan",
+        verifiable_context_runtime: sources.verifiableContextRuntime ? "artifacts/verifiable-context-runtime" : null,
+        readiness_runs: sources.readinessRuns ? "artifacts/readiness-runs" : null,
+        execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,
+        test_runs: sources.targetTestRuns ? "artifacts/test-runs" : null,
+        test_sandboxes: sources.targetTestSandboxes ? "artifacts/test-sandboxes" : null,
+    };
+}

package/dist/packages/{methods/package/method-stage-runner.d.ts → build-plans/package/build-plan-stage-runner.d.ts}

@@ -1,26 +1,26 @@
-import { type MethodExecutor } from "../../engine/agents/lib/executors.js";
-import { type RuntimeStageInstructions } from "../../engine/compile/lib/schema.js";
+import { type AgentExecutor } from "../../engine/agents/lib/executors.js";
+import { type RuntimeStageInstructions } from "../../engine/build/lib/schema.js";
 import type { RuntimeContractType } from "../../contracts/lib/schema.js";
-import { type RuntimeStageContractDraft } from "../../engine/compile/runtime.js";
-import { type MethodReporter, type MethodStageResult } from "./method-helpers.js";
-interface MethodStageShape<TContractType extends RuntimeContractType> {
+import { type RuntimeStageContractDraft } from "../../engine/build/runtime.js";
+import { type BuildPlanReporter, type BuildPlanStageResult } from "./build-plan-helpers.js";
+interface BuildPlanStageShape<TContractType extends RuntimeContractType> {
     id: string;
     label: string;
     contractType: TContractType;
 }
 interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType> {
-    executor: MethodExecutor;
-    compiledPath: string;
+    executor: AgentExecutor;
+    verifiableContextPath: string;
     executionPath?: string;
     targetName: string;
-    method: string;
-    methodSourcePath?: string;
-    stageDefinition: MethodStageShape<TContractType>;
+    buildPlan: string;
+    buildPlanSourcePath?: string;
+    stageDefinition: BuildPlanStageShape<TContractType>;
     instructions: RuntimeStageInstructions;
     summary: string;
     contract: RuntimeStageContractDraft;
     statusLines: string[];
-    reporter?: MethodReporter;
+    reporter?: BuildPlanReporter;
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
     syncWrites?: (() => void) | null;
@@ -34,5 +34,5 @@ interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType
 export declare function findStageByContractType<TStage extends {
     contractType: string;
 }>(stages: TStage[], contractType: TStage["contractType"]): TStage;
-export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<MethodStageResult>;
+export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<BuildPlanStageResult>;
 export {};

package/dist/packages/{methods/package/method-stage-runner.js → build-plans/package/build-plan-stage-runner.js}

@@ -1,9 +1,9 @@
-import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, } from "../../engine/compile/runtime.js";
-import { reportValidationFailure, } from "./method-helpers.js";
+import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, } from "../../engine/build/runtime.js";
+import { reportValidationFailure, } from "./build-plan-helpers.js";
 export function findStageByContractType(stages, contractType) {
     const stage = stages.find((candidate) => candidate.contractType === contractType);
     if (!stage) {
-        throw new Error(`Missing method stage for contract type: ${contractType}`);
+        throw new Error(`Missing Build Plan stage for contract type: ${contractType}`);
     }
     return stage;
 }
@@ -17,11 +17,11 @@ export async function executeValidatedStage(options) {
         : undefined;
     const code = await runExecutorStage({
         executor: options.executor,
-        compiledPath: options.compiledPath,
+        verifiableContextPath: options.verifiableContextPath,
         executionPath: options.executionPath,
-        compiledName: options.targetName,
-        method: options.method,
-        methodSourcePath: options.methodSourcePath,
+        verifiableContextName: options.targetName,
+        buildPlan: options.buildPlan,
+        buildPlanSourcePath: options.buildPlanSourcePath,
         stage: options.stageDefinition.id,
         stageLabel: options.stageDefinition.label,
         contractType: options.stageDefinition.contractType,
@@ -53,7 +53,7 @@ function finalizeValidatedStage(options, code) {
         if (completionSatisfied) {
             const validation = refreshAndValidate();
             if (validation.ok) {
-                markRuntimeRunSucceededAfterValidation(options.compiledPath, validation.summary);
+                markRuntimeRunSucceededAfterValidation(options.verifiableContextPath, validation.summary);
                 return {
                     ok: true,
                     code: 0,
@@ -61,7 +61,7 @@ function finalizeValidatedStage(options, code) {
                 };
             }
             reportValidationFailure(options.reporter, validation.summary);
-            markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
+            markRuntimeRunFailedAfterValidation(options.verifiableContextPath, validation.summary);
             return {
                 ok: false,
                 code,
@@ -73,7 +73,7 @@ function finalizeValidatedStage(options, code) {
     const validation = refreshAndValidate();
     if (!validation.ok) {
         reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
+        markRuntimeRunFailedAfterValidation(options.verifiableContextPath, validation.summary);
     }
     return {
         ok: validation.ok,

package/dist/packages/build-plans/package/builtin-build-plan.d.ts

@@ -0,0 +1,37 @@
+import { type BuildPlanArtifactKind } from "../../engine/build/build-plan-primitives.js";
+declare const BUILTIN_BUILD_PLAN_STAGE_IDS: {
+    readonly SUMMARIZE: "summarize";
+    readonly STRUCTURE: "structure";
+    readonly SHAPE: "shape";
+};
+type BuiltinBuildStageId = typeof BUILTIN_BUILD_PLAN_STAGE_IDS[keyof typeof BUILTIN_BUILD_PLAN_STAGE_IDS];
+export declare const BUILTIN_BUILD_PLAN_ARTIFACT_IDS: {
+    readonly SUMMARIES: "summaries";
+    readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
+    readonly KNOWLEDGE_CLAIMS: "knowledge-claims";
+    readonly KNOWLEDGE_INDEXES: "knowledge-indexes";
+    readonly HOME: "atlas";
+    readonly RUNTIME: "runtime";
+};
+export type BuiltinBuildPlanArtifactId = typeof BUILTIN_BUILD_PLAN_ARTIFACT_IDS[keyof typeof BUILTIN_BUILD_PLAN_ARTIFACT_IDS];
+export interface BuiltinBuildPlanArtifactSpec {
+    id: BuiltinBuildPlanArtifactId;
+    role: "input" | "working" | "output" | "runtime";
+    path: string;
+    kind: BuildPlanArtifactKind;
+    required: boolean;
+    description: string;
+}
+export interface BuiltinBuildStageAccessPattern {
+    id: BuiltinBuildStageId;
+    contract_type: string;
+    reads: BuiltinBuildPlanArtifactId[];
+    writes: BuiltinBuildPlanArtifactId[];
+}
+export declare function listBuiltinBuildPlanArtifactSpecs(): BuiltinBuildPlanArtifactSpec[];
+export declare function listBuiltinBuildPlanFallbackStages(): BuiltinBuildStageAccessPattern[];
+export declare function requiredBuildPlanArtifactOwners<TStage extends {
+    id: string;
+    writes: readonly string[];
+}>(stages: readonly TStage[], artifactId: BuiltinBuildPlanArtifactId): string[];
+export {};

package/dist/packages/build-plans/package/builtin-build-plan.js

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { z } from "zod";
+import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
+import { BuildPlanContextSchemaSchema } from "../../engine/build/lib/schema.js";
+import { PACKAGE_ROOT } from "./lib/package-root.js";
+const BUILTIN_BUILD_PLAN_STAGE_IDS = {
+    SUMMARIZE: "summarize",
+    STRUCTURE: "structure",
+    SHAPE: "shape",
+};
+export const BUILTIN_BUILD_PLAN_ARTIFACT_IDS = {
+    SUMMARIES: "summaries",
+    KNOWLEDGE_ENTITIES: "knowledge-entities",
+    KNOWLEDGE_CLAIMS: "knowledge-claims",
+    KNOWLEDGE_INDEXES: "knowledge-indexes",
+    HOME: "atlas",
+    RUNTIME: "runtime",
+};
+const BUILTIN_ARTIFACT_ID_SET = new Set(Object.values(BUILTIN_BUILD_PLAN_ARTIFACT_IDS));
+const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_BUILD_PLAN_STAGE_IDS));
+const BuiltinBuildPlanStageSchema = z.object({
+    id: z.string(),
+    contract_type: z.string(),
+    reads: z.array(z.string()),
+    writes: z.array(z.string()).min(1),
+});
+const BuiltinBuildPlanPackageSchema = z.object({
+    stages: z.array(BuiltinBuildPlanStageSchema).min(1),
+});
+let builtinBuildPlanContractCache = null;
+const BUILTIN_DEFAULT_WORKFLOW_ROOT = join(PACKAGE_ROOT, "public-repo", "build-plans", "interf-default");
+function assertBuiltinArtifactId(value) {
+    if (!BUILTIN_ARTIFACT_ID_SET.has(value)) {
+        throw new Error(`Built-in Interf Build Plan schema declares unsupported Artifact id "${value}".`);
+    }
+    return value;
+}
+function assertBuiltinStageId(value) {
+    if (!BUILTIN_STAGE_ID_SET.has(value)) {
+        throw new Error(`Built-in Interf Build Plan package declares unsupported stage id "${value}".`);
+    }
+    return value;
+}
+function loadBuiltinBuildPlanContract() {
+    if (builtinBuildPlanContractCache)
+        return builtinBuildPlanContractCache;
+    const schemaPath = join(BUILTIN_DEFAULT_WORKFLOW_ROOT, "build-plan.schema.json");
+    const buildPlanPath = join(BUILTIN_DEFAULT_WORKFLOW_ROOT, "build-plan.json");
+    const schema = readJsonFileWithSchema(schemaPath, "built-in Interf Build Plan schema", BuildPlanContextSchemaSchema);
+    if (!schema) {
+        throw new Error(`Missing or invalid built-in Build Plan package schema at ${schemaPath}.`);
+    }
+    const buildPlan = readJsonFileWithSchema(buildPlanPath, "built-in Interf Build Plan package", BuiltinBuildPlanPackageSchema);
+    if (!buildPlan) {
+        throw new Error(`Missing or invalid built-in Build Plan package at ${buildPlanPath}.`);
+    }
+    const artifacts = schema.artifacts.map((artifact) => {
+        const path = artifact.shape.path;
+        return {
+            id: assertBuiltinArtifactId(artifact.id),
+            role: "output",
+            path,
+            kind: artifact.shape.artifact_kind,
+            required: true,
+            description: artifact.description,
+        };
+    });
+    const stages = buildPlan.stages.map((stage) => ({
+        id: assertBuiltinStageId(stage.id),
+        contract_type: stage.contract_type,
+        reads: stage.reads.map(assertBuiltinArtifactId),
+        writes: stage.writes.map(assertBuiltinArtifactId),
+    }));
+    builtinBuildPlanContractCache = { artifacts, stages };
+    return builtinBuildPlanContractCache;
+}
+export function listBuiltinBuildPlanArtifactSpecs() {
+    return loadBuiltinBuildPlanContract().artifacts.map((artifact) => ({ ...artifact }));
+}
+export function listBuiltinBuildPlanFallbackStages() {
+    return loadBuiltinBuildPlanContract().stages.map((stage) => ({
+        ...stage,
+        reads: [...stage.reads],
+        writes: [...stage.writes],
+    }));
+}
+export function requiredBuildPlanArtifactOwners(stages, artifactId) {
+    return Array.from(new Set(stages
+        .filter((stage) => stage.writes.includes(artifactId))
+        .map((stage) => stage.id)));
+}

package/dist/packages/{methods → build-plans}/package/context-interface.d.ts

@@ -1,10 +1,10 @@
 import { z } from "zod";
-import { type MethodCompiledSchema, type MethodCompiledArtifact, type MethodArtifactId } from "../../engine/compile/lib/schema.js";
-export declare const CONTEXT_INTERFACE_FILE = "method.schema.json";
+import { type BuildPlanContextSchema, type BuildPlanArtifact, type BuildPlanArtifactId } from "../../engine/build/lib/schema.js";
+export declare const CONTEXT_INTERFACE_FILE = "build-plan.schema.json";
 export declare const ContextInterfaceSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"method-schema">;
+    kind: z.ZodLiteral<"build-plan-schema">;
     version: z.ZodLiteral<1>;
-    target_type: z.ZodLiteral<"compiled">;
+    target_type: z.ZodLiteral<"verifiable-context">;
     label: z.ZodString;
     artifacts: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -37,17 +37,17 @@ export declare const ContextInterfaceSchema: z.ZodObject<{
         built_by_stages: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const MethodInputSpecSchema: z.ZodObject<{
+export declare const BuildPlanInputSpecSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
     description: z.ZodString;
     required: z.ZodDefault<z.ZodBoolean>;
     examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-export type ContextInterface = MethodCompiledSchema;
-export type ContextInterfaceArtifact = MethodCompiledArtifact;
-export type ContextInterfaceArtifactId = MethodArtifactId;
-export type MethodInputSpec = z.infer<typeof MethodInputSpecSchema>;
+export type ContextInterface = BuildPlanContextSchema;
+export type ContextInterfaceArtifact = BuildPlanArtifact;
+export type ContextInterfaceArtifactId = BuildPlanArtifactId;
+export type BuildPlanInputSpec = z.infer<typeof BuildPlanInputSpecSchema>;
 interface ContextInterfaceStageLike {
     id: string;
     writes: readonly string[];
@@ -62,10 +62,10 @@ export declare function listContextInterfaceArtifacts(contextInterface: ContextI
 export declare function contextInterfaceFilePath(rootPath: string): string;
 export declare function resolveContextInterfacePath(rootPath: string): string | null;
 export declare function contextInterfaceExists(rootPath: string): boolean;
-export declare function contextInterfaceArtifactAbsolutePath(compiledPath: string, artifact: Pick<ContextInterfaceArtifact, "path">): string;
+export declare function contextInterfaceArtifactAbsolutePath(verifiableContextPath: string, artifact: Pick<ContextInterfaceArtifact, "path">): string;
 export declare function contextInterfaceArtifactPath(artifact: Pick<ContextInterfaceArtifact, "path" | "kind">): string;
 export declare function summarizeContextInterface(contextInterface: ContextInterface): ContextInterfaceSummary;
-export declare function deriveMethodInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): MethodInputSpec[];
+export declare function deriveBuildPlanInputsFromContextInterface(contextInterface: ContextInterface | null | undefined): BuildPlanInputSpec[];
 export declare function buildContextInterface(stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterfaceFile(rootPath: string, stages: ContextInterfaceStageLike[], label?: string): ContextInterface;
 export declare function writeContextInterface(rootPath: string, contextInterface: ContextInterface): ContextInterface;

package/dist/packages/{methods → build-plans}/package/context-interface.js

@@ -3,19 +3,19 @@ import { join } from "node:path";
 import { z } from "zod";
 import { warnInterf } from "../../contracts/utils/logger.js";
 import { readJsonFileUnchecked } from "../../contracts/utils/parse.js";
-import { MethodCompiledSchemaSchema, MethodArtifactIdSchema, } from "../../engine/compile/lib/schema.js";
-import { listBuiltinCompiledArtifactSpecs, requiredCompiledArtifactOwners, } from "./builtin-compiled-method.js";
-// Method packages define the context interface. The compiler persists the
+import { BuildPlanContextSchemaSchema, BuildPlanArtifactIdSchema, } from "../../engine/build/lib/schema.js";
+import { listBuiltinBuildPlanArtifactSpecs, requiredBuildPlanArtifactOwners, } from "./builtin-build-plan.js";
+// Build Plan packages define the context interface. The local engine persists the
 // same schema on disk, but higher layers should prefer this boundary when they
-// mean "the Method-declared shape a portable context must implement."
-export const CONTEXT_INTERFACE_FILE = "method.schema.json";
-export const ContextInterfaceSchema = MethodCompiledSchemaSchema;
+// mean "the Build Plan-declared shape verifiable context must implement."
+export const CONTEXT_INTERFACE_FILE = "build-plan.schema.json";
+export const ContextInterfaceSchema = BuildPlanContextSchemaSchema;
 // Package-owned input contract for authoring, review, and future authoring flows.
-// This does not change compiler execution semantics; it describes what data a
-// Method expects to organize before the compiler materializes the context
+// This does not change build execution semantics; it describes what data a
+// Build Plan expects to organize before the local engine materializes the context
 // interface on disk.
-export const MethodInputSpecSchema = z.object({
-    id: MethodArtifactIdSchema,
+export const BuildPlanInputSpecSchema = z.object({
+    id: BuildPlanArtifactIdSchema,
     label: z.string().min(1),
     description: z.string().min(1),
     required: z.boolean().default(false),
@@ -24,10 +24,10 @@ export const MethodInputSpecSchema = z.object({
 function normalizeContextInterface(contextInterface) {
     return {
         ...contextInterface,
-        kind: "method-schema",
+        kind: "build-plan-schema",
     };
 }
-function artifactToMethodArtifact(artifact) {
+function artifactToBuildPlanArtifact(artifact) {
     const path = artifact.shape.kind === "path" ? artifact.shape.path : artifact.id;
     return {
         id: artifact.id,
@@ -40,7 +40,7 @@ function artifactToMethodArtifact(artifact) {
     };
 }
 export function listContextInterfaceArtifacts(contextInterface) {
-    return contextInterface.artifacts.map(artifactToMethodArtifact);
+    return contextInterface.artifacts.map(artifactToBuildPlanArtifact);
 }
 function titleCaseArtifactId(artifactId) {
     return artifactId
@@ -59,8 +59,8 @@ export function resolveContextInterfacePath(rootPath) {
 export function contextInterfaceExists(rootPath) {
     return existsSync(contextInterfaceFilePath(rootPath));
 }
-export function contextInterfaceArtifactAbsolutePath(compiledPath, artifact) {
-    return join(compiledPath, artifact.path);
+export function contextInterfaceArtifactAbsolutePath(verifiableContextPath, artifact) {
+    return join(verifiableContextPath, artifact.path);
 }
 export function contextInterfaceArtifactPath(artifact) {
     if (artifact.kind === "file")
@@ -76,7 +76,7 @@ export function summarizeContextInterface(contextInterface) {
         runtimeArtifacts: artifacts.filter((artifact) => artifact.role === "runtime"),
     };
 }
-export function deriveMethodInputsFromContextInterface(contextInterface) {
+export function deriveBuildPlanInputsFromContextInterface(contextInterface) {
     if (!contextInterface)
         return [];
     return listContextInterfaceArtifacts(contextInterface)
@@ -88,13 +88,13 @@ export function deriveMethodInputsFromContextInterface(contextInterface) {
         required: artifact.required,
     }));
 }
-export function buildContextInterface(stages, label = "Method context interface") {
+export function buildContextInterface(stages, label = "Build Plan context interface") {
     return {
-        kind: "method-schema",
+        kind: "build-plan-schema",
         version: 1,
-        target_type: "compiled",
+        target_type: "verifiable-context",
         label,
-        artifacts: listBuiltinCompiledArtifactSpecs().map((artifact) => ({
+        artifacts: listBuiltinBuildPlanArtifactSpecs().map((artifact) => ({
             id: artifact.id,
             description: artifact.description,
             shape: {
@@ -103,7 +103,7 @@ export function buildContextInterface(stages, label = "Method context interface"
                 artifact_kind: artifact.kind === "file" ? "file" : "directory",
             },
             checks: [],
-            built_by_stages: requiredCompiledArtifactOwners(stages, artifact.id),
+            built_by_stages: requiredBuildPlanArtifactOwners(stages, artifact.id),
         })),
     };
 }
@@ -121,12 +121,12 @@ export function readContextInterface(rootPath) {
     const path = contextInterfaceFilePath(rootPath);
     if (!existsSync(path))
         return null;
-    const raw = readJsonFileUnchecked(path, "Method context interface");
+    const raw = readJsonFileUnchecked(path, "Build Plan context interface");
     if (raw === null)
         return null;
     const parsed = ContextInterfaceSchema.safeParse(raw);
     if (!parsed.success) {
-        warnInterf(`Warning: failed to validate Method context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        warnInterf(`Warning: failed to validate Build Plan context interface at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
         return null;
     }
     return normalizeContextInterface(parsed.data);

package/dist/packages/build-plans/package/interf-build-plan-package.d.ts

@@ -0,0 +1,31 @@
+import { type BuildPlanDefinition } from "./build-plan-definitions.js";
+export declare function writeBuildPlanPackageForVerifiableContext(verifiableContextPath: string, buildPlan: BuildPlanDefinition<string>): void;
+export declare function writeBuildPlanPackageToDir(buildPlanDir: string, buildPlan: BuildPlanDefinition<string>, options?: {
+    overwrite?: boolean;
+}): void;
+export declare function seedVerifiableContextBuildPlanPackage(options: {
+    verifiableContextPath: string;
+    prepDataDir: string;
+    buildPlanId: string;
+}): void;
+export declare function createLocalBuildPlanPackageFromTemplate(options: {
+    prepDataDir: string;
+    baseBuildPlanId: string;
+    buildPlanId: string;
+    label: string;
+    hint: string;
+    stagePolicyNotes: Record<string, string[]>;
+}): string;
+export declare function seedLocalBuildPlanPackageFromBase(options: {
+    prepDataDir: string;
+    baseBuildPlanId: string;
+    buildPlanId: string;
+    label: string;
+    hint: string;
+}): string;
+export declare function createScratchLocalBuildPlanPackage(options: {
+    prepDataDir: string;
+    buildPlanId: string;
+    label: string;
+    hint: string;
+}): string;