@interf/compiler 0.16.0 → 0.21.0

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

@@ -1,15 +1,21 @@
 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 { LocatorSchema, PreparationNameSchema, ReadinessStateSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, MethodIdSchema, } from "../../contracts/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());
 // ───────────────────────────────────────────────────────────────────────────
 // 0.13 — preparation-first additions
 // ───────────────────────────────────────────────────────────────────────────
-/** Source binding shape on the API (only `local-folder` ships in 0.13). */
+/**
+ * Source binding shape on the API. `local-folder` is the only kind the
+ * local binary accepts in 0.17; `remote-folder` rides in the type
+ * plumbing for the future cloud variant (B4.4 cloud-variant seam) and
+ * is rejected at the validator branch in server.ts. See `TODO(cloud)`
+ * marker there.
+ */
 export const SourceBindingSchema = z.object({
-    kind: z.enum(["local-folder"]),
+    kind: z.enum(["local-folder", "remote-folder"]),
     locator: z.string().min(1),
 }).strict();
 /**
@@ -45,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(),
@@ -59,6 +67,14 @@ export const PreparationCreateRequestSchema = z.object({
 export const PreparationUpdateRequestSchema = z.object({
     method_id: MethodIdSchema.nullable().optional(),
     about: z.string().nullable().optional(),
+    /**
+     * 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({
@@ -74,6 +90,17 @@ export const PreparationDeleteResponseSchema = z.object({
     deleted: z.boolean(),
     id: PreparationNameSchema,
 }).strict();
+export const PreparationWireShapeSchema = z.object({
+    id: PreparationNameSchema,
+    source: SourceBindingSchema,
+    method_id: MethodIdSchema.nullable(),
+    about: z.string().min(1).nullable(),
+    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
  * host (LAN IP, 0.0.0.0, public address) lets a remote browser tab POST at
@@ -178,12 +205,19 @@ 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: ReadinessStateSchema,
+    readiness: ReadinessSchema,
     runs: PreparationRunLinkageSchema,
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
+    // 0.17 — per-Artifact status from the latest compile run, mirrored
+    // here so the UI/CLI can render artifact rows without a separate
+    // GET /v1/preparations/<id>/runs fetch. Empty when the Method
+    // no compile run has produced artifacts yet.
+    artifacts: z.array(ArtifactStatusSchema).default([]),
 }).strict();
 export const MethodResourceSchema = z.object({
     id: MethodIdSchema,
@@ -191,10 +225,21 @@ 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([]),
-    output_paths: z.array(z.string().min(1)).default([]),
+    artifacts: z.array(ArtifactSchema).default([]),
     stages: z.array(z.object({
         id: z.string().min(1),
         label: z.string().min(1),
@@ -209,7 +254,6 @@ export const MethodResourceSchema = z.object({
         role: z.string().min(1).default("general"),
         reads: z.array(z.string().min(1)).default([]),
         writes: z.array(z.string().min(1)).default([]),
-        acceptance: z.record(z.string(), z.unknown()).optional(),
     }).strict()).default([]),
 }).strict();
 export const CompileRunCreateRequestSchema = z.object({
@@ -314,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),
@@ -391,6 +435,13 @@ export const ReadinessCheckDraftCreateRequestSchema = z.object({
 export const ReadinessCheckDraftResultSchema = z.object({
     checks: z.array(SourceReadinessCheckSchema).default([]),
 }).strict();
+export const MethodAuthoringArtifactRequirementSchema = z.object({
+    id: ArtifactIdSchema,
+    description: z.string().min(1).optional(),
+    shape: ArtifactPathShapeSchema,
+    checks: z.array(CheckSchema).default([]),
+    stage_hint: z.string().min(1).optional(),
+}).strict();
 export const MethodAuthoringCreateRequestSchema = z.object({
     preparation: PreparationNameSchema.nullable().optional(),
     source_folder_path: z.string().min(1),
@@ -401,6 +452,9 @@ 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({
     status: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
@@ -440,16 +494,19 @@ export const LocalJobRunResourceSchema = z.object({
 }).strict();
 export const VerifyRunStatusSchema = RunStatusSchema;
 /**
- * 0.15 cleanup — `mode` was a 0.13 hold-over from when verify could
- * judge against either the source-files baseline or the compiled
- * portable context. 0.13.1 redirected every verify run to compiled-
- * only, which made `mode` a vestigial field. We drop it here so the
- * wire shape matches the runtime behavior. Older clients sending
- * `mode` get it ignored by the strict-but-tolerant runtime parser
- * upstream.
+ * 0.17 — verify runs choose their judge target. `compiled` (default)
+ * judges against the latest portable-context output; `source-files`
+ * 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 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.
  */
 export const VerifyRunCreateRequestSchema = z.object({
     preparation: PreparationNameSchema,
+    target: TestTargetTypeSchema.default("compiled"),
 }).strict();
 export const VerifyRunResourceSchema = z.object({
     run_id: z.string().min(1),
@@ -460,7 +517,7 @@ export const VerifyRunResourceSchema = z.object({
     started_at: z.string().nullable().optional(),
     finished_at: z.string().nullable().optional(),
     readiness_run: ReadinessCheckRunSchema.nullable(),
-    readiness: ReadinessStateSchema.nullable().optional(),
+    readiness: ReadinessSchema.nullable().optional(),
     events: z.array(InterfRunEventSchema).default([]),
     error: z.string().min(1).nullable().optional(),
 }).strict();
@@ -588,13 +645,13 @@ export const PortableContextResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
     exists: z.boolean(),
-    readiness: ReadinessStateSchema,
+    readiness: ReadinessSchema,
     method: MethodIdSchema.nullable().optional(),
     latest_compile_run_id: z.string().min(1).nullable().optional(),
     latest_test_run_id: z.string().min(1).nullable().optional(),
     artifacts: z.array(ArtifactRefSchema).default([]),
 }).strict();
-export const ReadinessResourceSchema = ReadinessStateSchema;
+export const ReadinessResourceSchema = ReadinessSchema;
 export const SourceFileResourceSchema = z.object({
     preparation: PreparationNameSchema,
     path: z.string().min(1),
@@ -613,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(),
@@ -649,7 +712,7 @@ export const OpenPathResponseSchema = z.object({
     path: z.string().min(1),
 }).strict();
 export const PreparationListResponseSchema = z.object({
-    preparations: z.array(PreparationResourceSchema),
+    preparations: z.array(PreparationWireShapeSchema),
 }).strict();
 export const MethodListResponseSchema = z.object({
     methods: z.array(MethodResourceSchema),

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

@@ -14,7 +14,7 @@ import { createRunEventId, createRunEventTimestamp, } from "./execution/events.j
 import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../project/source-config.js";
 import { runMethodImprovementLoop } from "../methods/authoring/method-improvement.js";
 import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "./compile/compiled-paths.js";
-import { readCompiledSchemaFile } from "./compile/compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compile/compiled-schema.js";
 import { initializeCompiledRuntimeState } from "./compile/state.js";
 import { readinessPassRate, runReadinessChecksForExecutor, runSavedPortableContextCheck, } from "./verify/readiness-check-run.js";
 import { runMethodAuthoringDraft, } from "../methods/authoring/method-authoring.js";
@@ -87,9 +87,9 @@ function printSavedReadinessOutcome(prefix, outcome) {
 }
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    const zonePaths = (schema?.zones ?? [])
-        .filter((zone) => zone.kind !== "runtime")
-        .map((zone) => zone.path);
+    const artifactPaths = (schema ? listCompiledSchemaArtifacts(schema) : [])
+        .filter((artifact) => artifact.kind !== "runtime")
+        .map((artifact) => artifact.path);
     return [
         "AGENTS.md",
         "CLAUDE.md",
@@ -99,7 +99,7 @@ function bestVariationRestorePaths(compiledPath) {
         ".cursor",
         ".interf/interf.json",
         ".interf/method",
-        ...zonePaths,
+        ...artifactPaths,
     ];
 }
 function copyRelativePathIfPresent(sourceRoot, targetRoot, relativePath) {
@@ -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) {
@@ -598,12 +598,19 @@ export function createNativeLocalServiceRunHandlers(options = {}) {
                 preparationConfig: context.preparationConfig,
                 portableContextPath: context.compiledPath,
                 executor,
+                target: request.target,
             });
-            if (!result.compiledOutcome) {
+            const outcome = request.target === "source-files"
+                ? result.sourceFilesOutcome
+                : result.compiledOutcome;
+            if (!outcome) {
+                const targetLabel = request.target === "source-files"
+                    ? "Source files"
+                    : "Portable Context";
                 return {
                     ok: false,
                     readiness_run: result.readinessRun,
-                    error: "Portable Context is not ready for readiness checks.",
+                    error: `${targetLabel} is not ready for readiness checks.`,
                 };
             }
             return {
@@ -653,6 +660,9 @@ 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({
                     type: "log.appended",

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,18 +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;
+    requested_artifacts?: RequestedArtifact[];
+    source_profile?: SourceProfile | null;
+    checks?: SourceReadinessCheck[];
 }
 export interface StoredPreparation {
     id: string;
@@ -101,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 } : {}),
@@ -154,6 +156,22 @@ export function updateStoredPreparation(prepId, patch) {
             : patch.method_id !== undefined
                 ? { method: patch.method_id }
                 : {}),
+        ...(patch.checks !== undefined
+            ? { checks: patch.checks.map((check) => ({
+                    question: check.question,
+                    ...(check.answer ? { answer: check.answer } : {}),
+                    ...(check.strictness ? { strictness: check.strictness } : {}),
+                    ...(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
@@ -190,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

@@ -42,8 +42,14 @@ export declare const PREPARATION_SUBRESOURCES: {
      *   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:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    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

@@ -43,8 +43,14 @@ export const PREPARATION_SUBRESOURCES = {
      *   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:
+     *   GET /v1/preparations/<id>/artifacts/<artifact-id>
+     */
+    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

@@ -79,7 +79,7 @@ function buildTraceStreamChunks(runId, events) {
         time: event.timestamp ?? null,
         type: event.type,
         scope: event.stage_id ?? event.step_id ?? event.type,
-        message: event.message ?? event.summary ?? event.error ?? event.type,
+        message: event.message ?? event.summary ?? event.error ?? event.reason ?? event.type,
     }), event));
 }
 function proofChecksForCompileRun(run) {
@@ -164,7 +164,6 @@ export function compileRunToObservability(run) {
                 stage_total: stage.stage_total ?? null,
                 reads: stage.contract?.reads ?? [],
                 writes: stage.contract?.writes ?? [],
-                acceptance: stage.contract?.acceptance ?? null,
                 executor: stage.executor ?? null,
             },
         }, stage.stage_id));
@@ -223,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,
@@ -530,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-event-applier.js

@@ -86,6 +86,13 @@ export function applyEventToCompileRun(run, event) {
                 finished_at: run.finished_at ?? now,
                 events: [...run.events, event],
             };
+        case "run.cancelled":
+            return {
+                ...run,
+                status: "cancelled",
+                finished_at: run.finished_at ?? now,
+                events: [...run.events, event],
+            };
         case "readiness.updated":
             return {
                 ...run,

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;