@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/runtime/build/lib/schema.js

@@ -0,0 +1,494 @@
+import { z } from "zod";
+import { BUILD_PLAN_ARTIFACT_KINDS, } from "../build-plan-primitives.js";
+import { ArtifactIdSchema, ArtifactSchema, CheckSchema, ProjectIntentSchema, ProjectIdSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, StageEvidenceCountSchema, StageEvidenceEdgeSchema, StageEvidenceItemSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, InterfIdPattern, BuildPlanIdSchema, isInterfRelativePath, } from "../../../contracts/lib/schema.js";
+// `ArtifactSchema` is used internally below in `BuildPlanContextRawSchema`'s
+// `artifacts[]` field. The other Artifact* schemas/types are NOT
+// re-exported through this module — callers import them directly from
+// `contracts/lib/schema.js`. Re-exports with zero consumers were pruned
+// to keep this barrel narrow.
+export { GateStatusSchema, ProjectIntentSchema, ReadinessGateSchema, ReadinessSchema, ReadinessStatusSchema, VerifyTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceFilesSchema, SourceFileSchema, SourceKindSchema, SourceManifestAuditSchema, SourceManifestEvidenceSchema, SourceManifestFileKindSchema, SourceManifestFileSchema, SourceManifestScannerSchema, SourceManifestSchema, SourceInspectableUnitSchema, SourceSchema, SourceStateSchema, StageInputSchema, StageInputsSchema, StageEvidenceCountSchema, StageEvidenceEdgeSchema, StageEvidenceItemSchema, GraphManifestSchema, GraphManifestStageSummarySchema, GraphOutputCountsSchema, GraphReadinessRollupSchema, MetricCountSchema, MissingInputSchema, ResourceRefSchema, ResourceRoleSchema, ReviewedInputDecisionSchema, ReviewedInputSchema, StageManifestSchema, SourceBuildMaxAttemptsSchema, SourceBuildMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, BuildPlanIdSchema, } from "../../../contracts/lib/schema.js";
+import { BuildPlanContextCheckDraftSchema, } from "../../../build-plans/authoring/brief.js";
+const JsonRecordSchema = z.record(z.string(), z.unknown());
+// Lifecycle status of a built Context Graph as reported by `health.json`.
+// Defined once here and reused inside `ContextGraphHealthSchema.status` so the
+// `RuntimeStatus` type can never drift from the schema that validates the file.
+export const RuntimeStatusSchema = z.enum(["idle", "running", "built", "stale", "failed"]);
+// Which stage `health.json` reports: a terminal pseudo-stage
+// (`idle`/`built`/`failed`) or a concrete Build Plan stage id. This is the
+// SAME union used at `ContextGraphHealthSchema.stage`; the type is inferred
+// from it so the inline alias no longer widens to a bare `string`.
+export const BuildStageSchema = z.union([
+    z.enum(["idle", "built", "failed"]),
+    RuntimeStageSchema,
+]);
+// Status of one agent-run execution (a stage session and the run-scoped
+// ledger that records it). Single source for both `StageExecutionSessionSchema`
+// and `ExecutionStageLedgerSchema` so the two records can never disagree.
+export const ExecutionStatusSchema = z.enum(["running", "succeeded", "failed"]);
+export const BuildPlanArtifactIdSchema = z.string().regex(InterfIdPattern);
+export const BuildPlanArtifactKindSchema = z.enum(BUILD_PLAN_ARTIFACT_KINDS);
+export const BuildPlanArtifactRoleSchema = z.literal("output");
+export const BuildStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
+export const StageFingerprintSchema = z.string().regex(/^[a-f0-9]{64}$/);
+export const ContextGraphStageStateSchema = z.object({
+    contract_type: RuntimeContractTypeSchema.optional(),
+    status: BuildStageStatusSchema.optional(),
+    fingerprint: StageFingerprintSchema.optional(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    counts: z.record(z.string(), z.number()).optional(),
+    artifact_counts: z.record(z.string(), z.number()).optional(),
+    artifacts: z.array(z.string()).optional(),
+    summary: z.string().nullable().optional(),
+    run_id: z.string().nullable().optional(),
+});
+export const ContextGraphStateSchema = z.object({
+    version: z.number().int().min(1),
+    pending: z.array(z.string()),
+    stages: z.record(z.string().regex(InterfIdPattern), ContextGraphStageStateSchema).optional(),
+    last_add: z.string().nullable().optional(),
+    last_build: z.string().nullable().optional(),
+    warning_count: z.number().optional(),
+    error_count: z.number().optional(),
+}).strict();
+// A view-spec section, discriminated on `type` so each variant declares its
+// own path contract instead of one object where both `path?` and `paths?` are
+// always optional. The producer is `buildDefaultContextGraphViewSpec`
+// (state-view.ts): `status`/`cards` carry a single source `path`; `documents`
+// carries a `paths` list. `flow`/`table` have no producer yet, so their path
+// contract is genuinely unknown — both fields stay optional for those two
+// rather than guessing a shape no caller has committed to.
+const ViewSectionBaseFields = {
+    id: z.string(),
+    title: z.string(),
+};
+export const ViewSectionSchema = z.discriminatedUnion("type", [
+    z.object({ ...ViewSectionBaseFields, type: z.literal("status"), path: z.string() }),
+    z.object({ ...ViewSectionBaseFields, type: z.literal("cards"), path: z.string() }),
+    z.object({ ...ViewSectionBaseFields, type: z.literal("documents"), paths: z.array(z.string()) }),
+    z.object({
+        ...ViewSectionBaseFields,
+        type: z.literal("flow"),
+        path: z.string().optional(),
+        paths: z.array(z.string()).optional(),
+    }),
+    z.object({
+        ...ViewSectionBaseFields,
+        type: z.literal("table"),
+        path: z.string().optional(),
+        paths: z.array(z.string()).optional(),
+    }),
+]);
+export const ViewCardSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    metric: z.string(),
+    denominator_metric: z.string().optional(),
+    format: z.enum(["number", "fraction", "timestamp"]),
+});
+export const ContextGraphHealthSchema = z.object({
+    kind: z.literal("context-graph-health"),
+    version: z.number().int().min(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    status: RuntimeStatusSchema,
+    stage: BuildStageSchema,
+    summary: z.string(),
+    metrics: z.record(z.string(), z.number()),
+    checks: z.record(z.string(), z.boolean()),
+});
+export const ContextGraphViewSpecSchema = z.object({
+    kind: z.literal("context-graph-view-spec"),
+    version: z.number().int().min(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    health_source: z.string(),
+    state_source: z.string(),
+    default_note: z.string().nullable(),
+    document_scope: z.array(z.string()),
+    cards: z.array(ViewCardSchema),
+    sections: z.array(ViewSectionSchema),
+});
+export const BuildPlanPurposeSchema = z.object({
+    label: z.string().min(1),
+    task_hint: z.string().min(1),
+}).strict();
+/**
+ * Runtime projection of a single Build Plan artifact — the resolved
+ * shape stored in `.interf/build-plan/build-plan.json`. Distinct from
+ * the user-facing `Artifact` declaration in
+ * `contracts/lib/schema.ts` (which carries `shape`, `checks`, and
+ * `built_by_stages` at declaration time) and from `ArtifactRef` in
+ * `execution/lib/schema.ts` (the run-time event reference). One artifact
+ * passes through three lifecycle shapes: declared, projected, referenced.
+ */
+export const BuildPlanArtifactSchema = z.object({
+    id: BuildPlanArtifactIdSchema,
+    role: BuildPlanArtifactRoleSchema,
+    path: z.string().min(1).refine(isInterfRelativePath, {
+        message: "Artifact paths must stay inside the context graph root",
+    }),
+    kind: BuildPlanArtifactKindSchema,
+    required: z.boolean(),
+    owned_by: z.array(z.string().regex(InterfIdPattern)),
+    description: z.string().min(1),
+});
+// Persisted schema for the Build Plan-defined artifact interface that one
+// context graph must implement on disk.
+export const BuildPlanContextRawSchema = z.object({
+    kind: z.literal("build-plan-schema"),
+    version: z.literal(1),
+    target_type: z.literal("context-graph"),
+    label: z.string().min(1),
+    artifacts: z.array(ArtifactSchema).min(1),
+}).strict();
+export const BuildPlanContextSchemaSchema = BuildPlanContextRawSchema;
+export const BuildPlanRuntimeApiSchema = z.object({
+    kind: z.literal("build"),
+    version: z.literal(1),
+});
+export const BuildPlanStageArtifactReadAccessSchema = z.array(ArtifactIdSchema);
+export const BuildPlanStageArtifactWriteAccessSchema = z.array(ArtifactIdSchema).min(1);
+export const ExecutionShellArtifactMountSchema = z.object({
+    artifact_id: ArtifactIdSchema,
+    artifact_path: z.string(),
+    shell_root_path: z.string(),
+    input_mount_path: z.string().nullable(),
+    output_mount_path: z.string().nullable(),
+});
+export const ExecutionShellPathsSchema = z.object({
+    kind: z.literal("interf-execution-shell"),
+    version: z.literal(1),
+    build_plan: BuildPlanIdSchema,
+    stage: RuntimeStageSchema,
+    reads: z.array(ExecutionShellArtifactMountSchema),
+    writes: z.array(ExecutionShellArtifactMountSchema),
+});
+export const StageExecutionSessionValidationAttemptSchema = z.object({
+    attempt: z.number().int().min(1),
+    recorded_at: z.string().min(1),
+    status: z.enum(["succeeded", "failed"]),
+    summary: z.string().min(1),
+}).strict();
+/**
+ * Which kind of agent job a `StageExecutionSession` preserves. Every
+ * `executor.execute()` job that writes a graph-scoped session leaves the SAME
+ * inspectable session shape; `job_type` is the discriminator a reader keys off
+ * instead of inferring the job from coincidental fields. The default is `stage`
+ * so every existing writer/caller (a Build-Plan stage attempt inside a Context
+ * Graph) is unchanged. The stage-only fields (`stage_id`, `stage_label`,
+ * `contract_type`) stay populated for `stage`/`source-inventory` jobs.
+ *
+ * Only `stage` and `source-inventory` are ever produced by a session writer:
+ * `writeStageExecutionSessionStarted` defaults to `stage`, and source-inventory
+ * passes `jobType: "source-inventory"`. Graph-less jobs (Build Plan draft/
+ * improvement, benchmark-question drafting) record `LocalJobRun` instead — see
+ * `LocalJobTypeSchema` in `schemas/jobs.ts` — so their kinds never appear here.
+ *
+ * job_type -> preserved shell_type map (`PreservedShellTypeSchema` below):
+ *   stage             -> "stage-execution"
+ *   source-inventory  -> "stage-execution"
+ * The other `PreservedShellTypeSchema` members are driven by their own job
+ * substrate, NOT by an `AgentJobType`:
+ *   build-plan-authoring        <- LocalJobRun "build-plan-draft"
+ *   build-plan-improvement      <- LocalJobRun "build-plan-improvement"
+ *   benchmark-question-draft    <- LocalJobRun "benchmark-question-draft"
+ *   test-judge                  <- the verify/judge path (verify-execution.ts),
+ *                                  which is not an AgentJobType at all.
+ */
+export const AgentJobTypeSchema = z.enum([
+    "stage",
+    "source-inventory",
+]);
+export const StageExecutionSessionSchema = z.object({
+    kind: z.literal("interf-stage-execution-session"),
+    version: z.literal(1),
+    // `.default("stage")` lets every session written before this discriminator
+    // existed parse as a stage job, and keeps all current stage/source-inventory
+    // writers byte-identical without passing job_type explicitly.
+    job_type: AgentJobTypeSchema.default("stage"),
+    generated_at: z.string().min(1),
+    updated_at: z.string().min(1),
+    project: ProjectIdSchema,
+    project_intent: ProjectIntentSchema.nullable(),
+    context_graph_path: z.string().min(1),
+    build_plan: BuildPlanIdSchema,
+    build_run_id: z.string().min(1).nullable(),
+    // Stage identity: present for `stage`/`source-inventory` jobs (both produced
+    // here today). Kept nullable so a future non-stage `AgentJobType` could carry
+    // null without a schema migration.
+    stage_id: RuntimeStageSchema.nullable(),
+    stage_label: z.string().min(1).nullable(),
+    contract_type: RuntimeContractTypeSchema.nullable(),
+    stage_run_id: z.string().min(1),
+    attempt: z.number().int().min(1),
+    status: ExecutionStatusSchema,
+    executor: RuntimeExecutorInfoSchema,
+    shell: z.object({
+        root_path: z.string().min(1),
+        workspace_manifest_path: z.string().min(1).nullable(),
+        preserved_shell_manifest_path: z.string().min(1).nullable(),
+        replay_ready: z.boolean(),
+        // Why a non-replayable session is still truthful. Null while the shell is
+        // live; set when the shell was intentionally pruned (e.g. a successful
+        // attempt under `on-failure` retention) so "session exists" never implies a
+        // replay shell that is gone. When set, `replay_ready` is false and
+        // `preserved_shell_manifest_path` is null. `.default(null)` lets sessions
+        // written before this field existed parse without it.
+        retention_reason: z.string().min(1).nullable().default(null),
+    }).strict(),
+    logs: z.object({
+        prompt_path: z.string().min(1).nullable(),
+        event_stream_path: z.string().min(1).nullable(),
+        status_path: z.string().min(1).nullable(),
+    }).strict(),
+    runtime_files: z.object({
+        project_path: z.string().min(1).nullable(),
+        contract_path: z.string().min(1).nullable(),
+        paths_path: z.string().min(1).nullable(),
+        source_locator_path: z.string().min(1).nullable(),
+        source_manifest_path: z.string().min(1).nullable(),
+        source_state_path: z.string().min(1).nullable(),
+        stage_inputs_path: z.string().min(1).nullable(),
+        expected_inputs_path: z.string().min(1).nullable(),
+        reviewed_inputs_path: z.string().min(1).nullable(),
+        previous_attempts_path: z.string().min(1).nullable(),
+        retry_feedback_path: z.string().min(1).nullable(),
+        last_validation_failure_path: z.string().min(1).nullable(),
+        verifier_path: z.string().min(1).nullable(),
+        stage_evidence_path: z.string().min(1).nullable(),
+        // Best-effort transcript of the agent's reasoning/thinking spans, teed from
+        // the live event stream during the run (one JSON object per line). Null when
+        // the executor emitted no reasoning. This is the inspectable "full
+        // transcript" reference for a preserved attempt.
+        reasoning_path: z.string().min(1).nullable().default(null),
+    }).strict(),
+    artifacts: z.object({
+        reads: z.array(ExecutionShellArtifactMountSchema).default([]),
+        writes: z.array(ExecutionShellArtifactMountSchema).default([]),
+    }).strict(),
+    validation_attempts: z.array(StageExecutionSessionValidationAttemptSchema).default([]),
+    summary: z.string().min(1).nullable(),
+    error: z.string().min(1).nullable(),
+}).strict();
+export const RuntimeProjectContextSchema = z.object({
+    id: ProjectIdSchema,
+    intent: z.string().min(1).nullable(),
+}).strict();
+export const RuntimeStageInstructionsSchema = z.object({
+    stage_skill_dir: z.string().regex(InterfIdPattern),
+    effective_mode: z.enum(["builtin", "extend", "override"]),
+    local_mode: z.enum(["extend", "override"]).nullable(),
+    local_docs: z.array(z.string()),
+    mode_sources: z.array(z.string()),
+}).strict();
+export const RuntimeStageContractSchema = z.object({
+    kind: z.literal("interf-stage-contract"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    run_id: z.string(),
+    target_type: RuntimeTargetTypeSchema,
+    target_name: z.string(),
+    project: RuntimeProjectContextSchema,
+    build_plan: z.object({
+        id: BuildPlanIdSchema,
+        stage_index: z.number().nullable(),
+        stage_total: z.number(),
+        stages: z.array(RuntimeStageSchema),
+    }),
+    stage: RuntimeStageSchema,
+    stage_label: z.string(),
+    contract_type: RuntimeContractTypeSchema,
+    executor: RuntimeExecutorInfoSchema,
+    instructions: RuntimeStageInstructionsSchema,
+    counts: z.record(z.string(), z.number()),
+    artifacts: z.object({
+        reads: z.array(z.string()),
+        writes: z.array(z.string()),
+        write_contracts: z.array(z.object({
+            artifact_id: ArtifactIdSchema,
+            path: z.string().min(1),
+            checks: z.array(CheckSchema),
+        }).strict()).default([]),
+    }),
+    context_checks: z.array(BuildPlanContextCheckDraftSchema).default([]),
+    policies: z.object({
+        execution_mode: z.literal("deterministic"),
+        status_prefixes: z.array(z.string()),
+        notes: z.array(z.string()),
+        evidence_weighting: z.object({
+            required_fields: z.array(z.string()),
+            preserve_tiers: z.boolean(),
+        }).optional(),
+        working_set: z.object({
+            target_context_fraction: z.number(),
+            strategy: z.string(),
+        }).optional(),
+    }),
+});
+export const ExecutionStageLedgerSchema = z.object({
+    kind: z.literal("interf-run"),
+    version: z.literal(1),
+    run_id: z.string(),
+    target_type: RuntimeTargetTypeSchema,
+    target_name: z.string(),
+    build_plan: BuildPlanIdSchema,
+    stage: RuntimeStageSchema,
+    stage_label: z.string(),
+    contract_type: RuntimeContractTypeSchema,
+    status: ExecutionStatusSchema,
+    executor: RuntimeExecutorInfoSchema,
+    started_at: z.string(),
+    updated_at: z.string(),
+    finished_at: z.string().nullable(),
+    contract_path: z.string(),
+    execution_path: z.string().optional(),
+    counts: z.record(z.string(), z.number()),
+    output_artifacts: z.array(z.string()),
+    logs: z.object({
+        prompt_path: z.string(),
+        event_stream_path: z.string(),
+        status_path: z.string().optional(),
+    }).optional(),
+    evidence_path: z.string().min(1).optional(),
+    evidence: z.lazy(() => StageEvidenceReconciliationSchema).optional(),
+    summary: z.string(),
+    exit_code: z.number().nullable(),
+    error: z.string().nullable(),
+});
+export const RejectedStageEvidenceSchema = z.object({
+    kind: z.enum(["count", "item", "edge", "file"]),
+    id: z.string().min(1),
+    reason: z.string().min(1),
+}).strict();
+export const StageEvidenceReconciliationSchema = z.object({
+    kind: z.literal("interf-stage-evidence-reconciliation"),
+    version: z.literal(1),
+    generated_at: z.string().min(1),
+    evidence_path: z.string().min(1).nullable(),
+    accepted: z.object({
+        counts: z.array(StageEvidenceCountSchema).default([]),
+        items: z.array(StageEvidenceItemSchema).default([]),
+        edges: z.array(StageEvidenceEdgeSchema).default([]),
+    }).strict(),
+    rejected: z.array(RejectedStageEvidenceSchema).default([]),
+    warnings: z.array(z.string().min(1)).default([]),
+}).strict();
+export const ExecutionInventoryEntrySchema = z.object({
+    input_artifact: ArtifactIdSchema.optional(),
+    input_path: z.string().min(1).optional(),
+    output_artifact: ArtifactIdSchema,
+    output_path: z.string().min(1),
+    state: z.string().min(1).optional(),
+    metadata: JsonRecordSchema.optional(),
+}).strict();
+export const ExecutionInventorySchema = z.object({
+    // Both discriminators are always written by the only producers
+    // (`emptyExecutionInventory`/`buildInventoryFromEntries` in
+    // runtime-inventory.ts), so they are required, not optional. A persisted
+    // inventory missing `kind`/`version` is malformed and must fail to parse.
+    kind: z.literal("context-graph-runtime-ledger"),
+    version: z.literal(1),
+    stage: RuntimeStageSchema.optional(),
+    entries: z.array(ExecutionInventoryEntrySchema),
+    total: z.number().int().nonnegative(),
+});
+export const BuildPlanImprovementLoopSummarySchema = z.object({
+    variation: z.number().int().min(1),
+    kind: z.enum(["baseline", "edited"]),
+    attempts_run: z.number().int().min(1),
+    passed: z.boolean(),
+    passed_questions: z.number().int().min(0),
+    total_questions: z.number().int().min(0),
+    failed_stage: z.string().nullable().optional(),
+    test_run_path: z.string().nullable().optional(),
+    test_sandbox_path: z.string().nullable().optional(),
+    summary: z.string().min(1),
+});
+export const BuildPlanImprovementContextSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-loop"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    target_name: z.string(),
+    build_plan_id: BuildPlanIdSchema,
+    loop_index: z.number().int().min(1),
+    max_loops: SourceBuildMaxLoopsSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema,
+    review_paths: z.object({
+        build_plan_root: z.string(),
+        context_graph_runtime: z.string().nullable(),
+        benchmark_runs: z.string().nullable(),
+        execution_shells: z.string().nullable(),
+        test_runs: z.string().nullable(),
+        test_sandboxes: z.string().nullable(),
+    }),
+    benchmark_questions: z.object({
+        count: z.number().int().min(0),
+        questions: z.array(z.object({
+            id: z.string(),
+            question: z.string(),
+        })),
+    }),
+    previous_variations: z.array(BuildPlanImprovementLoopSummarySchema),
+    latest_failure: BuildPlanImprovementLoopSummarySchema.nullable(),
+});
+export const PreservedShellTypeSchema = z.enum([
+    "stage-execution",
+    "build-plan-authoring",
+    "build-plan-improvement",
+    "benchmark-question-draft",
+    "test-judge",
+]);
+export const PreservedShellStateSchema = z.object({
+    kind: z.literal("interf-preserved-shell"),
+    version: z.literal(1),
+    shell_type: PreservedShellTypeSchema,
+    generated_at: z.string(),
+    root_path: z.string(),
+    materialized_symlinks: z.number().int().min(0),
+});
+export const BuildPlanPackageValidationSchema = z.object({
+    ok: z.boolean(),
+    summary: z.string(),
+    errors: z.array(z.string()),
+    counts: z.record(z.string(), z.number()),
+});
+export const BuildPlanImprovementLoopRecordSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-loop-record"),
+    version: z.literal(1),
+    recorded_at: z.string(),
+    run_id: z.string(),
+    loop_index: z.number().int().min(1),
+    target_name: z.string(),
+    build_plan_id: BuildPlanIdSchema,
+    result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
+    changed: z.boolean(),
+    applied: z.boolean(),
+    summary: z.string(),
+    shell_path: z.string(),
+    loop_root_path: z.string(),
+    context_path: z.string(),
+    build_plan_before_path: z.string(),
+    build_plan_after_path: z.string(),
+    prompt_log_path: z.string(),
+    event_log_path: z.string(),
+    status_log_path: z.string(),
+    // The agent's reasoning transcript inside the preserved improvement shell
+    // (runtime/agent-reasoning.jsonl), so the record indexes the reasoning the
+    // same way a stage session exposes reasoning_path. Nullable for older records.
+    reasoning_path: z.string().nullable().default(null),
+    preserved_shell_manifest_path: z.string().nullable(),
+    validation: BuildPlanPackageValidationSchema.nullable(),
+});
+export const BuildPlanImprovementRunLedgerSchema = z.object({
+    kind: z.literal("interf-build-plan-improvement-run"),
+    version: z.literal(1),
+    generated_at: z.string(),
+    updated_at: z.string(),
+    run_id: z.string(),
+    target_name: z.string(),
+    build_plan_id: BuildPlanIdSchema,
+    max_loops: SourceBuildMaxLoopsSchema,
+    max_attempts: SourceBuildMaxAttemptsSchema,
+    loops: z.array(BuildPlanImprovementLoopRecordSchema),
+});

package/dist/packages/runtime/build/native-entrypoint.d.ts

@@ -0,0 +1,2 @@
+import type { AgentExecutor } from "../agents/lib/executors.js";
+export declare function createNativeEntrypointExecutor(): AgentExecutor;