@interf/compiler 0.9.1 → 0.9.4

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

@@ -1,5 +1,7 @@
 import { z } from "zod";
-import { COMPILED_ZONE_KINDS, } from "../workflow-primitives.js";
+import { COMPILED_ZONE_KINDS, } from "../method-primitives.js";
+import { RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
+export { ReadinessCheckSchema, ReadinessGateSchema, ReadinessStateSchema, ReadinessStatusSchema, ReadinessTargetResultSchema, RuntimeContractTypeSchema, RuntimeExecutorInfoSchema, RuntimeStageSchema, RuntimeTargetTypeSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, TestTargetTypeSchema, InterfIdPattern, MethodIdSchema, } from "../../contracts/lib/schema.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
 const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
 function isCompiledRelativePath(value) {
@@ -11,104 +13,10 @@ function isCompiledRelativePath(value) {
         .split(/[\\/]+/)
         .every((segment) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
 }
-export const RuntimeTargetTypeSchema = z.enum(["compiled"]);
-export const TestTargetTypeSchema = z.enum(["compiled", "raw"]);
-export const WorkflowIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
-export const RuntimeStageSchema = z.string().regex(WorkflowIdPattern);
-export const RuntimeContractTypeSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
-export const WorkflowZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
+export const MethodZoneIdSchema = z.string().regex(InterfIdPattern);
+export const MethodCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
+export const MethodZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
 export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
-export const SourceCompiledMaxAttemptsSchema = z.number().int().min(1).max(5);
-export const SourceCompiledMaxLoopsSchema = z.number().int().min(1).max(3);
-export const ReadinessStatusSchema = z.enum([
-    "not-configured",
-    "not-built",
-    "building",
-    "built",
-    "checking",
-    "ready",
-    "not-ready",
-    "stale",
-    "failed",
-]);
-export const ReadinessGateSchema = z.enum([
-    "preparation-config",
-    "portable-context",
-    "compile-run",
-    "readiness-checks",
-    "source-baseline",
-    "portable-context-check",
-    "checks-current",
-]);
-export const ReadinessCheckSchema = z.object({
-    gate: ReadinessGateSchema,
-    ok: z.boolean(),
-    status: ReadinessStatusSchema.optional(),
-    summary: z.string().min(1),
-    detail: z.string().min(1).optional(),
-    run_id: z.string().min(1).nullable().optional(),
-    artifact_path: z.string().min(1).nullable().optional(),
-}).strict();
-export const ReadinessTargetResultSchema = z.object({
-    passed: z.number().int().min(0),
-    total: z.number().int().min(0),
-    pass_rate: z.number().min(0).max(100).nullable(),
-    checks_fingerprint: z.string().min(1).nullable().optional(),
-    stale: z.boolean().default(false),
-    run_id: z.string().min(1).nullable().optional(),
-    run_path: z.string().min(1).nullable().optional(),
-}).strict();
-function normalizeReadinessState(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const input = value;
-    const output = { ...input };
-    if (typeof output.preparation !== "string" && typeof input.dataset === "string") {
-        output.preparation = input.dataset;
-    }
-    delete output.dataset;
-    if (Array.isArray(output.checks)) {
-        output.checks = output.checks.map((check) => {
-            if (!check || typeof check !== "object" || Array.isArray(check))
-                return check;
-            const normalizedCheck = { ...check };
-            if (normalizedCheck.gate === "dataset-config")
-                normalizedCheck.gate = "preparation-config";
-            return normalizedCheck;
-        });
-    }
-    if (output.compile && typeof output.compile === "object" && !Array.isArray(output.compile)) {
-        const compile = { ...output.compile };
-        if (compile.gate === "dataset-config")
-            compile.gate = "preparation-config";
-        output.compile = compile;
-    }
-    return output;
-}
-export const ReadinessStateSchema = z.preprocess(normalizeReadinessState, z.object({
-    kind: z.literal("interf-readiness-state"),
-    version: z.literal(1),
-    generated_at: z.string().min(1),
-    preparation: z.string().min(1),
-    status: ReadinessStatusSchema,
-    ready: z.boolean(),
-    summary: z.string().min(1),
-    portable_context_path: z.string().min(1).nullable(),
-    latest_compile_run_id: z.string().min(1).nullable().optional(),
-    latest_test_run_id: z.string().min(1).nullable().optional(),
-    compile: ReadinessCheckSchema.nullable(),
-    check_results: z.object({
-        configured: z.number().int().min(0),
-        fingerprint: z.string().min(1).nullable(),
-        source_files: ReadinessTargetResultSchema.nullable(),
-        portable_context: ReadinessTargetResultSchema.nullable(),
-        delta: z.number().nullable(),
-    }).strict(),
-    checks: z.array(ReadinessCheckSchema).default([]),
-}).strict());
 export const CompiledStageStateSchema = z.object({
     contract_type: RuntimeContractTypeSchema.optional(),
     status: CompiledStageStatusSchema.optional(),
@@ -123,7 +31,7 @@ export const CompiledStageStateSchema = z.object({
 export const CompiledStateSchema = z.object({
     version: z.number().int().min(1),
     pending: z.array(z.string()),
-    stages: z.record(z.string().regex(WorkflowIdPattern), CompiledStageStateSchema).optional(),
+    stages: z.record(z.string().regex(InterfIdPattern), CompiledStageStateSchema).optional(),
     last_add: z.string().nullable().optional(),
     last_compile: z.string().nullable().optional(),
     warning_count: z.number().optional(),
@@ -179,39 +87,39 @@ export const CompiledRawSnapshotSchema = z.object({
     source_total: z.number(),
     sample_files: z.array(z.string()),
 });
-export const WorkflowPurposeSchema = z.object({
+export const MethodPurposeSchema = z.object({
     label: z.string().min(1),
     task_hint: z.string().min(1),
 }).strict();
-export const WorkflowZoneSchema = z.object({
-    id: WorkflowZoneIdSchema,
-    role: WorkflowZoneRoleSchema,
+export const MethodZoneSchema = z.object({
+    id: MethodZoneIdSchema,
+    role: MethodZoneRoleSchema,
     path: z.string().min(1).refine(isCompiledRelativePath, {
         message: "Zone paths must stay inside the compiled root",
     }),
-    kind: WorkflowCompiledZoneKindSchema,
+    kind: MethodCompiledZoneKindSchema,
     required: z.boolean(),
-    owned_by: z.array(z.string().regex(WorkflowIdPattern)),
+    owned_by: z.array(z.string().regex(InterfIdPattern)),
     description: z.string().min(1),
 });
-export const WorkflowCompiledZoneSchema = WorkflowZoneSchema;
-// Persisted schema for the workflow-defined context interface that one
-// compiled context must implement on disk.
-export const WorkflowSchemaSchema = z.object({
-    kind: z.literal("workflow-schema"),
+export const MethodCompiledZoneSchema = MethodZoneSchema;
+// Persisted schema for the method-defined context interface that one
+// portable context must implement on disk.
+export const MethodSchemaSchema = z.object({
+    kind: z.literal("method-schema"),
     version: z.literal(1),
     target_type: z.literal("compiled"),
     label: z.string().min(1),
-    zones: z.array(WorkflowZoneSchema).min(1),
+    zones: z.array(MethodZoneSchema).min(1),
 });
-export const WorkflowCompiledSchemaSchema = WorkflowSchemaSchema;
-export const WorkflowCompilerApiSchema = z.object({
+export const MethodCompiledSchemaSchema = MethodSchemaSchema;
+export const MethodCompilerApiSchema = z.object({
     kind: z.literal("compiled"),
     version: z.literal(1),
 });
-export const WorkflowStageZoneAccessSchema = z.array(WorkflowZoneIdSchema).min(1);
+export const MethodStageZoneAccessSchema = z.array(MethodZoneIdSchema).min(1);
 export const ExecutionShellZoneMountSchema = z.object({
-    zone_id: WorkflowZoneIdSchema,
+    zone_id: MethodZoneIdSchema,
     compiled_path: z.string(),
     shell_root_path: z.string(),
     input_mount_path: z.string().nullable(),
@@ -220,23 +128,13 @@ export const ExecutionShellZoneMountSchema = z.object({
 export const ExecutionShellPathsSchema = z.object({
     kind: z.literal("interf-execution-shell"),
     version: z.literal(1),
-    workflow: WorkflowIdSchema,
+    method: MethodIdSchema,
     stage: RuntimeStageSchema,
     reads: z.array(ExecutionShellZoneMountSchema),
     writes: z.array(ExecutionShellZoneMountSchema),
 });
-export const RuntimeExecutorInfoSchema = z.object({
-    kind: z.enum(["local-agent", "connected-provider", "managed"]),
-    name: z.string(),
-    display_name: z.string(),
-    command: z.string().nullable(),
-    model: z.string().nullable().optional(),
-    effort: z.string().nullable().optional(),
-    profile: z.string().nullable().optional(),
-    timeout_ms: z.number().nullable().optional(),
-});
 export const RuntimeStageInstructionsSchema = z.object({
-    stage_skill_dir: z.string().regex(WorkflowIdPattern),
+    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()),
@@ -248,12 +146,12 @@ export const RuntimeStageAcceptanceSchema = z.object({
     stage_equals_counts: z.record(z.string(), z.string()).optional(),
     stage_at_least: z.record(z.string(), z.number()).optional(),
     stage_at_least_counts: z.record(z.string(), z.string()).optional(),
-    zone_counts_at_least: z.record(z.string().regex(WorkflowIdPattern), z.number()).optional(),
-    zone_counts_at_least_counts: z.record(z.string().regex(WorkflowIdPattern), z.string()).optional(),
-    markdown_frontmatter_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
-    frontmatter_required_keys_in_zones: z.record(WorkflowZoneIdSchema, z.array(z.string().min(1)).min(1)).optional(),
-    markdown_abstract_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
-    wikilinks_valid_in_zones: z.array(WorkflowZoneIdSchema).optional(),
+    zone_counts_at_least: z.record(z.string().regex(InterfIdPattern), z.number()).optional(),
+    zone_counts_at_least_counts: z.record(z.string().regex(InterfIdPattern), z.string()).optional(),
+    markdown_frontmatter_valid_zones: z.array(MethodZoneIdSchema).optional(),
+    frontmatter_required_keys_in_zones: z.record(MethodZoneIdSchema, z.array(z.string().min(1)).min(1)).optional(),
+    markdown_abstract_valid_zones: z.array(MethodZoneIdSchema).optional(),
+    wikilinks_valid_in_zones: z.array(MethodZoneIdSchema).optional(),
     artifacts_must_not_contain: z.record(z.string(), z.array(z.string().min(1))).optional(),
 }).strict();
 export const RuntimeStageContractSchema = z.object({
@@ -263,8 +161,8 @@ export const RuntimeStageContractSchema = z.object({
     run_id: z.string(),
     target_type: RuntimeTargetTypeSchema,
     target_name: z.string(),
-    workflow: z.object({
-        id: WorkflowIdSchema,
+    method: z.object({
+        id: MethodIdSchema,
         stage_index: z.number().nullable(),
         stage_total: z.number(),
         stages: z.array(RuntimeStageSchema),
@@ -301,7 +199,7 @@ export const RuntimeRunSchema = z.object({
     run_id: z.string(),
     target_type: RuntimeTargetTypeSchema,
     target_name: z.string(),
-    workflow: WorkflowIdSchema,
+    method: MethodIdSchema,
     stage: RuntimeStageSchema,
     stage_label: z.string(),
     contract_type: RuntimeContractTypeSchema,
@@ -324,9 +222,9 @@ export const RuntimeRunSchema = z.object({
     error: z.string().nullable(),
 });
 export const CompiledInventoryEntrySchema = z.object({
-    input_zone: WorkflowZoneIdSchema.optional(),
+    input_zone: MethodZoneIdSchema.optional(),
     input_path: z.string().min(1).optional(),
-    output_zone: WorkflowZoneIdSchema,
+    output_zone: MethodZoneIdSchema,
     output_path: z.string().min(1),
     state: z.string().min(1).optional(),
     metadata: JsonRecordSchema.optional(),
@@ -338,24 +236,7 @@ export const CompiledInventorySchema = z.object({
     entries: z.array(CompiledInventoryEntrySchema),
     total: z.number().int().nonnegative(),
 });
-export const TestCaseExpectSchema = z.object({
-    must_include: z.array(z.string().min(1)).optional(),
-    must_include_one_of: z.array(z.array(z.string().min(1)).min(1)).optional(),
-    must_not_include: z.array(z.string().min(1)).optional(),
-    min_words: z.number().int().nonnegative().optional(),
-    max_words: z.number().int().nonnegative().optional(),
-}).refine((value) => value.min_words === undefined ||
-    value.max_words === undefined ||
-    value.max_words >= value.min_words, {
-    message: "max_words must be greater than or equal to min_words",
-}).refine((value) => (value.must_include?.length ?? 0) > 0 ||
-    (value.must_include_one_of?.length ?? 0) > 0 ||
-    (value.must_not_include?.length ?? 0) > 0 ||
-    value.min_words !== undefined ||
-    value.max_words !== undefined, {
-    message: "Test expectations must include at least one check",
-});
-export const WorkflowImprovementLoopSummarySchema = z.object({
+export const MethodImprovementLoopSummarySchema = z.object({
     variation: z.number().int().min(1),
     kind: z.enum(["baseline", "edited"]),
     attempts_run: z.number().int().min(1),
@@ -367,17 +248,17 @@ export const WorkflowImprovementLoopSummarySchema = z.object({
     test_sandbox_path: z.string().nullable().optional(),
     summary: z.string().min(1),
 });
-export const WorkflowImprovementContextSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-loop"),
+export const MethodImprovementContextSchema = z.object({
+    kind: z.literal("interf-method-improvement-loop"),
     version: z.literal(1),
     generated_at: z.string(),
     target_name: z.string(),
-    workflow_id: WorkflowIdSchema,
+    method_id: MethodIdSchema,
     loop_index: z.number().int().min(1),
     max_loops: SourceCompiledMaxLoopsSchema,
     max_attempts: SourceCompiledMaxAttemptsSchema,
     review_paths: z.object({
-        workflow_root: z.string(),
+        method_root: z.string(),
         compiled_runtime: z.string().nullable(),
         test_comparisons: z.string().nullable(),
         execution_shells: z.string().nullable(),
@@ -391,12 +272,13 @@ export const WorkflowImprovementContextSchema = z.object({
             question: z.string(),
         })),
     }),
-    previous_variations: z.array(WorkflowImprovementLoopSummarySchema),
-    latest_failure: WorkflowImprovementLoopSummarySchema.nullable(),
+    previous_variations: z.array(MethodImprovementLoopSummarySchema),
+    latest_failure: MethodImprovementLoopSummarySchema.nullable(),
 });
 export const PreservedShellTypeSchema = z.enum([
     "stage-execution",
-    "workflow-improvement",
+    "method-authoring",
+    "method-improvement",
 ]);
 export const PreservedShellSnapshotSchema = z.object({
     kind: z.literal("interf-preserved-shell"),
@@ -406,20 +288,20 @@ export const PreservedShellSnapshotSchema = z.object({
     root_path: z.string(),
     materialized_symlinks: z.number().int().min(0),
 });
-export const WorkflowPackageValidationSchema = z.object({
+export const MethodPackageValidationSchema = z.object({
     ok: z.boolean(),
     summary: z.string(),
     errors: z.array(z.string()),
     counts: z.record(z.string(), z.number()),
 });
-export const WorkflowImprovementLoopRecordSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-loop-record"),
+export const MethodImprovementLoopRecordSchema = z.object({
+    kind: z.literal("interf-method-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(),
-    workflow_id: WorkflowIdSchema,
+    method_id: MethodIdSchema,
     result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
     changed: z.boolean(),
     applied: z.boolean(),
@@ -427,23 +309,23 @@ export const WorkflowImprovementLoopRecordSchema = z.object({
     shell_path: z.string(),
     loop_root_path: z.string(),
     context_path: z.string(),
-    workflow_before_path: z.string(),
-    workflow_after_path: z.string(),
+    method_before_path: z.string(),
+    method_after_path: z.string(),
     prompt_log_path: z.string(),
     event_log_path: z.string(),
     status_log_path: z.string(),
     preserved_shell_manifest_path: z.string().nullable(),
-    validation: WorkflowPackageValidationSchema.nullable(),
+    validation: MethodPackageValidationSchema.nullable(),
 });
-export const WorkflowImprovementRunLedgerSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-run"),
+export const MethodImprovementRunLedgerSchema = z.object({
+    kind: z.literal("interf-method-improvement-run"),
     version: z.literal(1),
     generated_at: z.string(),
     updated_at: z.string(),
     run_id: z.string(),
     target_name: z.string(),
-    workflow_id: WorkflowIdSchema,
+    method_id: MethodIdSchema,
     max_loops: SourceCompiledMaxLoopsSchema,
     max_attempts: SourceCompiledMaxAttemptsSchema,
-    loops: z.array(WorkflowImprovementLoopRecordSchema),
+    loops: z.array(MethodImprovementLoopRecordSchema),
 });

package/dist/packages/compiler/{workflows.d.ts → method-runs.d.ts}

@@ -1,6 +1,6 @@
 import { type InterfConfig } from "../project-model/interf-detect.js";
-export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "../workflow-package/workflow-helpers.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+export type { MethodReporter, MethodStageResult, LocalSkillContractExtension } from "../method-package/method-helpers.js";
+export { methodQueryDirectory, methodImproveDirectory, methodCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../method-package/method-helpers.js";
 export type CompiledCheck = "compiled" | "stage";
 export interface DetectedInterfTarget {
     path: string;
@@ -9,7 +9,7 @@ export interface DetectedInterfTarget {
     config: InterfConfig;
 }
 export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
-export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
-export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledWorkflowValidation;
+export declare function createCompiled(name: string, sourcePath: string, methodId?: string, about?: string, sourceFolderPath?: string): string;
+export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledMethodValidation;
 export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
 export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";

package/dist/packages/compiler/{workflows.js → method-runs.js}

@@ -1,7 +1,8 @@
 import { createCompiled as createCompiledScaffold, } from "../project-model/interf-scaffold.js";
 import { detectInterf } from "../project-model/interf-detect.js";
 import { validateCompiledCompile, } from "./validate.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../workflow-package/workflow-helpers.js";
+import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
+export { methodQueryDirectory, methodImproveDirectory, methodCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "../method-package/method-helpers.js";
 export function detectCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
@@ -13,8 +14,8 @@ export function detectCompiled(cwd) {
         config: detected.config,
     };
 }
-export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
-    return createCompiledScaffold(name, sourcePath, workflowId, about, datasetPath);
+export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath = sourcePath) {
+    return createCompiledScaffold(name, sourcePath, methodId, about, sourceFolderPath);
 }
 export function verifyCompiledCheck(check, compiledPath) {
     switch (check) {

package/dist/packages/compiler/raw-snapshot.d.ts

@@ -27,21 +27,14 @@ export declare function resolveCompiledRawPath(compiledPath: string, config?: {
         path: string;
         control_path?: string | undefined;
         preparation_path?: string | undefined;
-        source_folder_path?: string | undefined;
-        dataset_path?: string | undefined;
     };
     about?: string | undefined;
-    workflow?: string | undefined;
     max_attempts?: number | undefined;
     max_loops?: number | undefined;
     method_origin?: {
         selected: string;
         local_draft?: boolean | undefined;
     } | undefined;
-    workflow_origin?: {
-        selected: string;
-        local_draft?: boolean | undefined;
-    } | undefined;
 } | null): string;
 export declare function syncCompiledRawSnapshot(compiledPath: string, sourcePath?: string): CompiledRawSyncResult;
 export declare function ensureCompiledRawBinding(compiledPath: string): InterfConfig | null;

package/dist/packages/compiler/raw-snapshot.js

@@ -36,7 +36,6 @@ export function ensureCompiledRawBinding(compiledPath) {
             ...(config.source ?? {}),
             path: "./raw",
             control_path: config.source?.control_path ?? defaultControlPathForCompiled(compiledPath),
-            ...(config.source?.dataset_path ? { dataset_path: config.source.dataset_path } : {}),
         },
     };
     return saveCompiledInterfConfig(compiledPath, nextConfig);

package/dist/packages/compiler/reset.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { initializeCompiledRuntimeState } from "./state.js";
-import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, workflowPackagePathForCompiled, } from "./compiled-paths.js";
+import { stageExecutionShellsRoot, testRootForCompiled, testTargetsRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeRoot, compiledRuntimeLogsRoot, methodPackagePathForCompiled, } from "./compiled-paths.js";
 function removeIfExists(path) {
     if (existsSync(path)) {
         rmSync(path, { recursive: true, force: true });
@@ -36,7 +36,7 @@ export function clearCompiledRuntimeDerivedArtifacts(compiledPath) {
     removeIfExists(compiledQueryAcceptanceRoot(compiledPath));
 }
 function activeCompiledInputRoots(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const roots = new Set();
     for (const zone of schema?.zones ?? []) {
         if (zone.role !== "input")
@@ -63,7 +63,7 @@ export function resetCompiledGeneratedState(compiledPath, scope = "compile") {
     initializeCompiledRuntimeState(compiledPath);
     if (scope === "all") {
         removeIfExists(stageExecutionShellsRoot(compiledPath));
-        removeIfExists(workflowImprovementLoopsRoot(compiledPath));
+        removeIfExists(methodImprovementLoopsRoot(compiledPath));
         removeIfExists(compiledRuntimeLogsRoot(compiledPath));
         removeIfExists(join(compiledRuntimeRoot(compiledPath), "run-history.jsonl"));
         removeIfExists(testRootForCompiled(compiledPath));

package/dist/packages/compiler/runtime-acceptance.js

@@ -2,12 +2,13 @@ import { existsSync, } from "node:fs";
 import { join } from "node:path";
 import { listFilesRecursive } from "../shared/filesystem.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { METHOD_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
 import { RuntimeStageContractSchema, } from "./lib/schema.js";
 import { stageContractPath } from "./runtime-paths.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { loadState } from "./state-io.js";
 import { countBrokenWikilinks, isOutputMarkdownFile, safeReadText, validateSynthFiles } from "./validate.js";
+import { countCompiledZoneArtifacts } from "./artifact-counts.js";
 function toFiniteNumber(value) {
     if (typeof value !== "number" || !Number.isFinite(value))
         return null;
@@ -41,14 +42,6 @@ function readPathValue(record, keyPath) {
         return current[segment];
     }, record);
 }
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
 function markdownFilesForZone(compiledPath, zonePath, kind) {
     const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
     if (!existsSync(absolutePath))
@@ -59,7 +52,7 @@ function markdownFilesForZone(compiledPath, zonePath, kind) {
     return listFilesRecursive(absolutePath, isOutputMarkdownFile);
 }
 function zoneRoots(compiledPath, acceptanceZones) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     if (!schema)
         return [];
     return acceptanceZones
@@ -103,12 +96,12 @@ export function validateResolvedStageAcceptance(dirPath, options) {
             failures: [],
         };
     }
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     if (!schema) {
         return {
             ok: false,
-            summary: `Stage acceptance failed for ${options.stageId}: missing workflow schema.`,
-            failures: [`Missing method/${WORKFLOW_SCHEMA_FILE}.`],
+            summary: `Stage acceptance failed for ${options.stageId}: missing Method schema.`,
+            failures: [`Missing method/${METHOD_SCHEMA_FILE}.`],
         };
     }
     const failures = [];
@@ -159,7 +152,7 @@ export function validateResolvedStageAcceptance(dirPath, options) {
             failures.push(`Acceptance references unknown zone "${zoneId}".`);
             continue;
         }
-        const actual = countZoneArtifacts(dirPath, zone.path, zone.kind);
+        const actual = countCompiledZoneArtifacts(dirPath, zone.path, zone.kind);
         if (actual < minimum) {
             failures.push(`Expected zone "${zoneId}" to contain at least ${minimum} artifact(s), got ${actual}.`);
         }
@@ -175,7 +168,7 @@ export function validateResolvedStageAcceptance(dirPath, options) {
             failures.push(`Acceptance references missing count "${countKey}" for zone "${zoneId}".`);
             continue;
         }
-        const actual = countZoneArtifacts(dirPath, zone.path, zone.kind);
+        const actual = countCompiledZoneArtifacts(dirPath, zone.path, zone.kind);
         if (actual < expected) {
             failures.push(`Expected zone "${zoneId}" to contain at least count "${countKey}" (${expected}) artifact(s), got ${actual}.`);
         }

package/dist/packages/compiler/runtime-contracts.js

@@ -1,7 +1,7 @@
-import { WORKFLOW_SCHEMA_FILE } from "./compiled-schema.js";
+import { METHOD_SCHEMA_FILE } from "./compiled-schema.js";
 export function buildRuntimeStageContract(options) {
     const localSkillDocs = options.localSkillDocs ?? [];
-    const workflowNotes = options.workflowNotes ?? [];
+    const methodNotes = options.methodNotes ?? [];
     return {
         instructions: options.instructions,
         counts: {
@@ -12,7 +12,7 @@ export function buildRuntimeStageContract(options) {
         artifacts: {
             reads: [
                 "interf.json",
-                `method/${WORKFLOW_SCHEMA_FILE}`,
+                `method/${METHOD_SCHEMA_FILE}`,
                 ...(options.extraReadArtifacts ?? []),
                 ...options.stageReadArtifacts,
                 ...localSkillDocs,
@@ -26,19 +26,19 @@ export function buildRuntimeStageContract(options) {
             execution_mode: "deterministic",
             status_prefixes: ["STATUS:", "DONE:", "BLOCKED:", "ERROR:"],
             notes: [
-                `This is the "${options.stageLabel}" stage for the compiled context "${options.compiledName}".`,
-                "The workflow package is the authoritative method layer for this run.",
-                `Use \`method/${WORKFLOW_SCHEMA_FILE}\` as the deterministic context-interface reference for this portable context.`,
-                "Honor the declared read and write artifacts instead of inventing a parallel workflow.",
+                `This is the "${options.stageLabel}" stage for the portable context "${options.compiledName}".`,
+                "The Method package is the authoritative method layer for this run.",
+                `Use \`method/${METHOD_SCHEMA_FILE}\` as the deterministic context-interface reference for this portable context.`,
+                "Honor the declared read and write artifacts instead of inventing a parallel process.",
                 "Only create or update files that fall under the declared write targets for this stage.",
                 "Interf writes `.interf/runtime/` ledgers such as run, state, health, and view-spec files. Read them if needed, but do not create, edit, or replace them in this stage unless the contract explicitly marks a runtime artifact as stage-owned.",
                 "Keep scratch extraction commands single-purpose and non-destructive. Avoid wildcard cleanup and multi-command chains.",
-                ...workflowNotes,
+                ...methodNotes,
                 ...(localSkillDocs.length > 0
                     ? [
                         "Read any local instruction docs listed in the contract before you write artifacts or declare the stage complete.",
                         options.instructions.effective_mode === "override"
-                            ? "Local stage docs replace the default workflow guidance for this run, but they still do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation."
+                            ? "Local stage docs replace the default method guidance for this run, but they still do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation."
                             : "Local stage docs can refine the stage behavior, but they do not bypass required writes, declared proof artifacts, or deterministic runtime reconciliation.",
                     ]
                     : []),

package/dist/packages/compiler/runtime-prompt.js

@@ -3,16 +3,16 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
     const modeNotes = instructions.effective_mode === "override"
         ? [
             "Local stage instruction docs are authoritative for this run.",
-            "Use bundled workflow heuristics only when the stage contract explicitly permits them.",
+            "Use bundled Method heuristics only when the stage contract explicitly permits them.",
             "Interf still enforces the same required reads, writes, verifier outputs, and runtime reconciliation at stage close.",
         ]
         : instructions.effective_mode === "extend"
             ? [
-                "Use the current compiled workflow docs as the default workflow for this run.",
+                "Use the current compiled Method docs as the default Method for this run.",
                 "Then apply any additional local stage instruction docs referenced by the contract as stage-specific extensions.",
             ]
             : [
-                "Use the current compiled workflow docs as the default workflow for this run.",
+                "Use the current compiled Method docs as the default Method for this run.",
             ];
     return [
         `Interf Method stage docs: method/compile/stages/${stageSkillDir}/`,
@@ -31,7 +31,7 @@ export function buildStagePrompt(instructions, contractPath, statusLines) {
         "If `AGENTS.md` is listed in the contract, use it only for portable-context routing that is directly relevant to this stage.",
         "`.interf/runtime/run.json`, `.interf/runtime/state.json`, `.interf/runtime/health.json`, and `.interf/runtime/view-spec.json` are runtime artifacts written by Interf. You may read them, but do not create, edit, or replace them unless the contract explicitly marks a different proof artifact as stage-owned.",
         "If a contract-listed output file does not exist yet, create it in one whole-file write. Do not attempt patch-style edits against a missing runtime path.",
-        "Stay inside the current compiled context. Do not try to open repo docs, repo source files, or other paths outside the compiled context unless the stage contract explicitly requires them.",
+        "Stay inside the current portable context. Do not try to open repo docs, repo source files, or other paths outside the portable context unless the stage contract explicitly requires them.",
         instructions.effective_mode === "override"
             ? "Do not depend on any repo-root or globally installed skill cache for this run. Local stage instruction docs are the primary Method layer for this run."
             : "Do not depend on any repo-root or globally installed skill cache for this run. Use the current compiled Method docs and the contract as the default behavior.",

package/dist/packages/compiler/runtime-reconcile.d.ts

@@ -1,2 +1,2 @@
-import { type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
-export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<WorkflowStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;
+import { type MethodStageDefinition } from "../method-package/method-definitions.js";
+export declare function reconcileCompiledStageRun(dirPath: string, stage: Pick<MethodStageDefinition, "id" | "contractType" | "reads" | "writes">): boolean;