@interf/compiler 0.18.0 → 0.21.0

package/dist/packages/engine/lib/schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ArtifactRefSchema, CompileRunSchema, CompileRunStatusSchema, InterfRunEventSchema, ProofRecordSchema, RunObservabilitySchema, } from "../execution/lib/schema.js";
-import { SourcePreparationConfigSchema, SourceReadinessCheckSchema, } from "../../project/lib/schema.js";
+import { RequestedArtifactSchema, SourcePreparationConfigSchema, SourceProfileSchema, SourceReadinessCheckSchema, } from "../../project/lib/schema.js";
 import { ArtifactSchema, ArtifactIdSchema, ArtifactPathShapeSchema, ArtifactStatusSchema, CheckSchema, LocatorSchema, PreparationNameSchema, ReadinessSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, TestTargetTypeSchema, } from "../../contracts/lib/schema.js";
 import { ReadinessCheckRunSchema, } from "../verify/lib/schema.js";
 const JsonObjectSchema = z.record(z.string(), z.unknown());
@@ -51,12 +51,14 @@ export const PreparationCreateRequestSchema = z.object({
     id: PreparationNameSchema,
     source: SourceBindingSchema,
     /**
-     * Method binding. Optional — a preparation can be created with no
-     * method bound, then have one selected (or drafted) later before the
-     * first compile. Null/missing means "method not chosen yet".
+     * Selected Build Plan / Method package id. Optional — a Preparation
+     * can be created with requested Artifacts first, then have a Build Plan
+     * selected or drafted later before the first compile.
      */
     method_id: MethodIdSchema.nullable().optional(),
     about: z.string().min(1).optional(),
+    requested_artifacts: z.array(RequestedArtifactSchema).default([]),
+    source_profile: SourceProfileSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
@@ -66,11 +68,13 @@ export const PreparationUpdateRequestSchema = z.object({
     method_id: MethodIdSchema.nullable().optional(),
     about: z.string().nullable().optional(),
     /**
-     * Replace the full quality-check list. Use the empty array to clear
+     * Replace the full readiness-check list. Use the empty array to clear
      * every check. Each item is a `SourceReadinessCheck`
      * (`{ question, answer?, strictness?, expect? }`).
      */
     checks: z.array(SourceReadinessCheckSchema).optional(),
+    requested_artifacts: z.array(RequestedArtifactSchema).optional(),
+    source_profile: SourceProfileSchema.nullable().optional(),
 }).strict();
 /** Body of `POST /v1/methods` — install a Method package by path. */
 export const MethodInstallRequestSchema = z.object({
@@ -94,6 +98,8 @@ export const PreparationWireShapeSchema = z.object({
     config_path: z.string().min(1),
     portable_context: ArtifactLocatorSchema,
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    requested_artifacts: z.array(RequestedArtifactSchema).default([]),
+    source_profile: SourceProfileSchema.nullable().optional(),
 }).strict();
 /**
  * The local service must only ever bind to a loopback interface. Any other
@@ -199,6 +205,8 @@ export const PreparationResourceSchema = z.object({
     source_path: z.string().min(1),
     method_id: MethodIdSchema.nullable(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    requested_artifacts: z.array(RequestedArtifactSchema).default([]),
+    source_profile: SourceProfileSchema.nullable().optional(),
     portable_context: PortableContextMappingSchema,
     portable_context_path: z.string().min(1).nullable(),
     readiness: ReadinessSchema,
@@ -217,6 +225,17 @@ export const MethodResourceSchema = z.object({
     path: z.string().min(1),
     label: z.string().min(1).optional(),
     hint: z.string().min(1).optional(),
+    purpose: z.object({
+        label: z.string().min(1),
+        task_hint: z.string().min(1),
+    }).strict().optional(),
+    inputs: z.array(z.object({
+        id: ArtifactIdSchema,
+        label: z.string().min(1),
+        description: z.string().min(1),
+        required: z.boolean().default(false),
+        examples: z.array(z.string().min(1)).optional(),
+    }).strict()).default([]),
     source_kind: z.enum(["builtin", "local"]).default("local"),
     built_in: z.boolean().default(false),
     active_for_preparations: z.array(PreparationNameSchema).default([]),
@@ -339,7 +358,7 @@ export const PreparationSetupResultSchema = z.object({
     version: z.literal(1),
     operation: z.enum(["create", "select-method"]),
     preparation: PreparationNameSchema,
-    method: MethodIdSchema,
+    method: MethodIdSchema.nullable(),
     source_folder_path: z.string().min(1),
     config_path: z.string().min(1),
     portable_context_path: z.string().min(1),
@@ -433,6 +452,8 @@ export const MethodAuthoringCreateRequestSchema = z.object({
     hint: z.string().min(1),
     task_prompt: z.string().min(1),
     checks: z.array(SourceReadinessCheckSchema).default([]),
+    requested_artifacts: z.array(RequestedArtifactSchema).default([]),
+    source_profile: SourceProfileSchema.nullable().optional(),
     artifact_requirements: z.array(MethodAuthoringArtifactRequirementSchema).default([]),
 }).strict();
 export const MethodAuthoringResultSchema = z.object({
@@ -478,7 +499,7 @@ export const VerifyRunStatusSchema = RunStatusSchema;
  * judges against the raw source folder for a baseline that reveals
  * how much value the Method actually adds. The 0.15 cleanup made
  * verify compiled-only on the wire because the source-files branch
- * had been retired in 0.13.1; 0.17 restores it because the QA tab and
+ * had been retired in 0.13.1; 0.17 restores it because the readiness-check UI and
  * `verify/README.md` have always claimed the option exists, and the
  * sandbox + spec builders for source-files have remained in tree
  * since 0.13.
@@ -649,30 +670,36 @@ export const LocalServiceDiscoverySchema = z.object({
     kind: z.literal("interf-local-service-discovery"),
     version: z.literal(1),
     resources: z.object({
+        instance: z.string().min(1),
         preparations: z.string().min(1),
         methods: z.string().min(1),
         runs: z.string().min(1),
-        readiness: z.string().min(1),
-        portable_contexts: z.string().min(1),
-        source_files: z.string().min(1),
-        workspace_files: z.string().min(1),
         action_proposals: z.string().min(1),
-        preparation_setups: z.string().min(1),
-        preparation_changes: z.string().min(1),
-        method_changes: z.string().min(1),
-        workspace_bootstraps: z.string().min(1).optional(),
-        readiness_check_drafts: z.string().min(1),
-        method_authoring_runs: z.string().min(1),
-        method_improvement_runs: z.string().min(1),
-        compile_runs: z.string().min(1),
-        verify_runs: z.string().min(1),
-        reset: z.string().min(1),
         executor: z.string().min(1),
+        open_path: z.string().min(1),
         /**
          * 0.15 — connected agents primitive. Optional during the 0.14 →
          * 0.15 rollout so older clients don't fail discovery validation.
          */
         agents: z.string().min(1).optional(),
+        /**
+         * Older discovery fields. Resource access is now preparation-scoped,
+         * but accepting these keys keeps stale clients from failing parse.
+         */
+        readiness: z.string().min(1).optional(),
+        portable_contexts: z.string().min(1).optional(),
+        source_files: z.string().min(1).optional(),
+        workspace_files: z.string().min(1).optional(),
+        preparation_setups: z.string().min(1).optional(),
+        preparation_changes: z.string().min(1).optional(),
+        method_changes: z.string().min(1).optional(),
+        workspace_bootstraps: z.string().min(1).optional(),
+        readiness_check_drafts: z.string().min(1).optional(),
+        method_authoring_runs: z.string().min(1).optional(),
+        method_improvement_runs: z.string().min(1).optional(),
+        compile_runs: z.string().min(1).optional(),
+        verify_runs: z.string().min(1).optional(),
+        reset: z.string().min(1).optional(),
         workspaces: z.string().min(1).optional(),
         status: z.string().min(1).optional(),
     }).strict(),

package/dist/packages/engine/native-run-handlers.js

@@ -182,7 +182,7 @@ async function runMethodVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run saved readiness checks against the Portable Context after prepare.",
+                    fatalError: "Could not run saved readiness checks against the Portable Context after compile.",
                 };
             }
             console.log();
@@ -244,7 +244,7 @@ function summarizeMethodVariation(options) {
         : options.result.bestOutcome
             ? `Best result: ${passedChecks}/${totalChecks} readiness checks passed.`
             : options.result.failedStage
-                ? `Prepare failed at stage ${options.result.failedStage} before any saved readiness result.`
+                ? `Compile failed at stage ${options.result.failedStage} before any saved readiness result.`
                 : "Method variation did not produce a passing result.";
     return {
         variation: options.variation,
@@ -274,14 +274,14 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
 function printPostCompileNextStep(options) {
     console.log(chalk.dim(`  Portable Context: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add readiness checks, then `interf verify`."));
+        console.log(chalk.dim("  Next: run `interf` to add readiness checks, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf verify` if you also want readiness evidence for source files and Portable Context."));
+        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf test` if you also want readiness evidence for source files and Portable Context."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf verify` to collect readiness evidence for source files and Portable Context."));
+    console.log(chalk.dim("  Next: run `interf test` to collect readiness evidence for source files and Portable Context."));
 }
 function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -322,11 +322,11 @@ export async function runConfiguredCompiledCompile(options) {
             console.log(chalk.dim("  Interf will rerun the same Method variation, check the Portable Context agents can use, and stop early if it passes."));
         }
         else {
-            console.log(chalk.dim("  Compilation mode: 1 attempt per Method variation."));
+            console.log(chalk.dim("  Compile mode: 1 attempt per Method variation."));
         }
         if (maxLoops != null) {
-            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} Method edits after retries fail.`));
-            console.log(chalk.dim("  Interf will review failed runs, edit the Method, and test new Method variations."));
+            console.log(chalk.dim(`  Method improvement: up to ${maxLoops} Method edits after retries fail.`));
+            console.log(chalk.dim("  Interf will review failed runs, edit the Build Plan, and test new Method variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
@@ -660,6 +660,8 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 hint: request.hint,
                 taskPrompt: request.task_prompt,
                 checks: request.checks,
+                requestedArtifacts: request.requested_artifacts,
+                sourceProfile: request.source_profile ?? null,
                 artifactRequirements: request.artifact_requirements,
                 executor,
                 onStatus: (line) => context.emit({

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

@@ -19,7 +19,7 @@
  *
  * 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;
@@ -30,24 +30,18 @@ export interface PreparationCreateInput {
     /** Method binding. Null/undefined means "not bound yet" — bind later via update. */
     method_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;
     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;
@@ -107,4 +101,6 @@ export declare function preparationWireShape(stored: StoredPreparation): {
         value: string;
     };
     checks: SourcePreparationConfig["checks"];
+    requested_artifacts: SourcePreparationConfig["requested_artifacts"];
+    source_profile: SourcePreparationConfig["source_profile"] | null;
 };

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

@@ -106,6 +106,8 @@ export function createStoredPreparation(runtime, input) {
             ...(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 } : {}),
@@ -162,6 +164,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
@@ -198,5 +208,7 @@ export function preparationWireShape(stored) {
         config_path: stored.configPath,
         portable_context: { kind: "local-path", value: stored.portableContextPath },
         checks: stored.config.checks ?? [],
+        requested_artifacts: stored.config.requested_artifacts ?? [],
+        source_profile: stored.config.source_profile ?? null,
     };
 }

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

@@ -0,0 +1,5 @@
+import type { RequestedArtifact } from "../project/lib/schema.js";
+import type { MethodAuthoringArtifactRequirement } 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[]): MethodAuthoringArtifactRequirement[];

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

@@ -49,7 +49,7 @@ export declare const PREPARATION_SUBRESOURCES: {
      */
     readonly artifacts: "artifacts";
 };
-/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
+/** Method Activity sub-resources (relative to /v1/methods/<id>/). */
 export declare const METHOD_SUBRESOURCES: {
     readonly runs: "runs";
     /**

package/dist/packages/engine/routes.js

@@ -50,7 +50,7 @@ export const PREPARATION_SUBRESOURCES = {
      */
     artifacts: "artifacts",
 };
-/** Method-scoped sub-resources (relative to /v1/methods/<id>/). */
+/** Method Activity sub-resources (relative to /v1/methods/<id>/). */
 export const METHOD_SUBRESOURCES = {
     runs: "runs",
     /**

package/dist/packages/engine/run-observability.js

@@ -222,7 +222,7 @@ export function compileRunToObservability(run) {
             { label: "Method", value: run.method },
             { label: "Executor", value: executor?.display_name ?? run.backend },
             { label: "Stages", value: `${run.stages.filter((stage) => stage.status === "succeeded").length}/${run.stages.length}` },
-            { label: "Proof", value: `${proof.filter((check) => check.ok).length}/${proof.length}` },
+            { label: "Stage proof", value: `${proof.filter((check) => check.ok).length}/${proof.length}` },
             { label: "Artifacts", value: String(artifacts.length) },
         ],
         artifacts,
@@ -529,7 +529,8 @@ export function jobRunToObservability(job) {
         events.push(traceEvent(job.run_id, "run_cancelled", completedAt, eventIndex++));
     }
     const outputPath = job.output_path ?? (typeof job.result?.path === "string" ? job.result.path : null);
-    const artifacts = uniqueArtifacts(outputPath ? [{ path: outputPath, role: "output" }] : []);
+    const outputIsArtifact = job.job_type !== "method-authoring" && job.job_type !== "method-improvement";
+    const artifacts = uniqueArtifacts(outputIsArtifact && outputPath ? [{ path: outputPath, role: "output" }] : []);
     return RunObservabilityResourceSchema.parse({
         kind: "interf-run-observability",
         version: 1,

package/dist/packages/engine/runtime-proposal-helpers.d.ts

@@ -1,6 +1,6 @@
 import { type SourcePreparationConfig } from "../project/lib/schema.js";
 import { type ActionProposalPlanActionType, type ActionProposalResource } from "./lib/schema.js";
-export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+export declare const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Build Plan and I will prepare an approval proposal.";
 export type LocalTestMode = "source-files" | "compiled" | "both";
 export declare function createActionProposalId(): string;
 export declare function sanitizeActionProposalPlan(value: unknown): unknown;
@@ -19,7 +19,7 @@ export declare function directServiceEndpointForAction(actionType: ActionProposa
 export declare function numberValue(values: Record<string, unknown> | undefined, key: string): number | null;
 export declare function testModeFromValues(values: Record<string, unknown> | undefined): LocalTestMode | null;
 export declare function testModeValue(values: Record<string, unknown> | undefined, defaultMode?: LocalTestMode): LocalTestMode;
-export declare function testModeCliTarget(mode: LocalTestMode): "source-files" | "portable-context" | "both";
+export declare function testModeCliTarget(mode: LocalTestMode): "source-files" | "compiled";
 export declare function methodIdForProposal(message: string, values: Record<string, unknown> | undefined): string;
 export declare function actionValueMethodTaskPrompt(values: Record<string, unknown> | undefined): string | null;
 export declare function normalizeMethodAuthoringText(value: string): string;

package/dist/packages/engine/runtime-proposal-helpers.js

@@ -14,7 +14,7 @@ import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../proje
 import { createCompiledTestTarget, } from "./verify/verify-targets.js";
 import { methodAuthoringTaskPrompt, MethodAuthoringActionValuesSchema, } from "./action-values.js";
 import { ActionProposalPlanActionTypeSchema, } from "./lib/schema.js";
-export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf Workspace. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Method and I will prepare an approval proposal.";
+export const ACTION_PLANNER_CLARIFICATION_MESSAGE = "I can help with this Interf instance. Ask a question about Interf, or ask me to create a Preparation, prepare, check readiness, improve, or draft a Build Plan and I will prepare an approval proposal.";
 export function createActionProposalId() {
     return `action_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -112,15 +112,13 @@ export function testModeFromValues(values) {
         return "compiled";
     return value === "source-files" || value === "compiled" || value === "both" ? value : null;
 }
-export function testModeValue(values, defaultMode = "both") {
+export function testModeValue(values, defaultMode = "compiled") {
     return testModeFromValues(values) ?? defaultMode;
 }
 export function testModeCliTarget(mode) {
     if (mode === "source-files")
         return "source-files";
-    if (mode === "compiled")
-        return "portable-context";
-    return "both";
+    return "compiled";
 }
 export function methodIdForProposal(message, values) {
     const explicit = stringValue(values, "method_id") ??
@@ -210,13 +208,13 @@ export function actionCommandPreview(actionType, preparationName, methodId, valu
     if (actionType === "compile") {
         const methodSuffix = methodId ? ` # Method: ${methodId}` : "";
         return preparationName
-            ? `interf compile --preparation ${preparationName}${methodSuffix}`
+            ? `interf compile ${preparationName}${methodSuffix}`
             : `interf compile${methodSuffix}`;
     }
     if (actionType === "test") {
         const mode = testModeCliTarget(testModeValue(values));
         return preparationName
-            ? `interf test --preparation ${preparationName} --target ${mode}`
+            ? `interf test ${preparationName} --target ${mode}`
             : `interf test --target ${mode}`;
     }
     if (actionType === "readiness-check-draft") {

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

@@ -44,6 +44,11 @@ export declare function buildMethodResource(resource: {
     path: string;
     label?: string;
     hint?: string;
+    purpose?: {
+        label: string;
+        taskHint: string;
+    };
+    inputs?: MethodResource["inputs"];
     source_kind: "builtin" | "local";
     built_in: boolean;
     active_for_preparations: string[];

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

@@ -85,7 +85,7 @@ 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")
@@ -97,7 +97,7 @@ export function readinessSummaryForStatus(status) {
     if (status === "not-built")
         return "Portable 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) {
@@ -115,6 +115,8 @@ export function buildPreparationResource(rootPath, preparation, readiness, lates
         source_path: resolveSourcePreparationPath(rootPath, preparation),
         method_id: methodId,
         checks: preparation.checks,
+        requested_artifacts: preparation.requested_artifacts ?? [],
+        source_profile: preparation.source_profile ?? null,
         portable_context: {
             preparation: preparation.name,
             path: readiness.portable_context_path,
@@ -141,6 +143,15 @@ export function buildMethodResource(resource) {
         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

@@ -275,7 +275,7 @@ 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
+     * Method Activity 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.
@@ -354,7 +354,9 @@ export declare class LocalServiceRuntime {
     private resolvePreparationConfig;
     private ensureCompiledForRun;
     private readCompileRun;
+    private hydrateCompileRunFromRuntime;
     private finalizeInterruptedCompileRuns;
+    private finalizeInterruptedJobRuns;
     /**
      * 0.17 — emit per-Artifact billing events when a compile run reaches
      * a terminal state. STUB FORM: writes a JSONL file alongside the run