@interf/compiler 0.9.1 → 0.9.3

package/dist/packages/method-package/method-definitions.js

@@ -0,0 +1,205 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { isMethodId, listLocalMethodDefinitions, loadLocalMethodDefinition, loadMethodDefinitionFromDir, } from "./local-methods.js";
+import { warnInterf } from "../shared/logger.js";
+import { methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { resolveSourceControlPath } from "../project-model/interf.js";
+import { PACKAGE_ROOT } from "./lib/package-root.js";
+import { deriveMethodInputsFromContextInterface, } from "./context-interface.js";
+import { mergeStagePolicyNotesForStages } from "./method-stage-policy.js";
+const DEFAULT_METHOD_ID = "interf-default";
+let builtinDefaultMethodCache = null;
+function toMethodStages(stages) {
+    return stages.map((stage) => ({
+        id: stage.id,
+        label: stage.label,
+        description: stage.description ?? stage.label,
+        contractType: stage.contract_type,
+        skillDir: stage.skill_dir ?? stage.id,
+        reads: [...stage.reads],
+        writes: [...stage.writes],
+        ...(stage.acceptance ? { acceptance: stage.acceptance } : {}),
+    }));
+}
+export function standaloneMethodDefinitionFromLocalPackage(local) {
+    if (!local.stages || local.stages.length === 0) {
+        throw new Error(`Method package "${local.id}" is missing explicit stages. Compiled-local and portable Method packages must be standalone.`);
+    }
+    const stages = toMethodStages(local.stages);
+    const contextInterface = local.method_schema;
+    const inputs = local.inputs?.length
+        ? [...local.inputs]
+        : deriveMethodInputsFromContextInterface(contextInterface);
+    return {
+        id: local.id,
+        compilerApi: local.compiler_api ?? {
+            kind: "compiled",
+            version: 1,
+        },
+        ...(local.purpose
+            ? {
+                purpose: {
+                    label: local.purpose.label,
+                    taskHint: local.purpose.task_hint,
+                },
+            }
+            : {}),
+        inputs,
+        label: local.label,
+        hint: local.hint,
+        recommended: false,
+        contextInterface,
+        ...(contextInterface ? { schema: contextInterface } : {}),
+        stages,
+        stagePolicyNotes: mergeStagePolicyNotesForStages(stages, undefined, local.stage_policy_notes),
+        starterDocs: [...local.starter_docs],
+        scope: "local",
+    };
+}
+function builtinMethodPackagePath(methodId) {
+    return join(PACKAGE_ROOT, "builtin-methods", methodId);
+}
+function getBuiltinDefaultMethod() {
+    if (builtinDefaultMethodCache)
+        return builtinDefaultMethodCache;
+    const local = loadMethodDefinitionFromDir(builtinMethodPackagePath(DEFAULT_METHOD_ID));
+    if (!local) {
+        throw new Error(`Missing built-in Interf Method package at builtin-methods/${DEFAULT_METHOD_ID}.`);
+    }
+    const resolved = standaloneMethodDefinitionFromLocalPackage(local);
+    builtinDefaultMethodCache = {
+        ...resolved,
+        id: DEFAULT_METHOD_ID,
+        recommended: true,
+        scope: "builtin",
+    };
+    return builtinDefaultMethodCache;
+}
+function listBuiltinCompiledMethods() {
+    return [getBuiltinDefaultMethod()];
+}
+function resolveCompiledMethodFromLocal(methodId, sourcePath) {
+    const local = loadLocalMethodDefinition(sourcePath, methodId);
+    if (!local)
+        return null;
+    const resolved = standaloneMethodDefinitionFromLocalPackage(local);
+    return resolved;
+}
+export function listCompiledMethodChoices(sourcePath) {
+    const builtins = listBuiltinCompiledMethods();
+    if (!sourcePath)
+        return builtins;
+    const methodsById = new Map();
+    for (const method of builtins) {
+        methodsById.set(method.id, method);
+    }
+    for (const definition of listLocalMethodDefinitions(sourcePath)) {
+        try {
+            const method = resolveCompiledMethodFromLocal(definition.id, sourcePath);
+            if (method)
+                methodsById.set(method.id, method);
+        }
+        catch (error) {
+            warnInterf(`Warning: skipping local Method "${definition.id}" because it could not be resolved cleanly: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return [...methodsById.values()];
+}
+export function getCompiledMethod(methodId, options = {}) {
+    const builtin = listBuiltinCompiledMethods().find((candidate) => candidate.id === methodId);
+    if (builtin)
+        return builtin;
+    if (options.sourcePath) {
+        const local = resolveCompiledMethodFromLocal(methodId, options.sourcePath);
+        if (local)
+            return local;
+        throw new Error(`No local Method package found for "${methodId}" under ${join(options.sourcePath, "interf", "methods", methodId)}.`);
+    }
+    throw new Error(`Method "${methodId}" is not built-in. Provide a source path so Interf can resolve a local Method package.`);
+}
+export function getActiveCompiledMethod(compiledPath) {
+    const methodPath = methodPackagePathForCompiled(compiledPath);
+    if (existsSync(join(methodPath, "method.json"))) {
+        const local = loadMethodDefinitionFromDir(methodPath);
+        if (!local) {
+            throw new Error(`Local Method package at ${methodPath} is missing or invalid. Interf compile runs the local package directly; recreate or reseed this portable context.`);
+        }
+        return standaloneMethodDefinitionFromLocalPackage(local);
+    }
+    throw new Error(`Missing local Method package at ${methodPath}. Interf compile runs the local package directly, so recreate or reseed this portable context under ${resolveSourceControlPath(compiledPath)}.`);
+}
+export function resolveCompiledMethodId(value) {
+    if (typeof value === "string" && isMethodId(value)) {
+        return value;
+    }
+    return null;
+}
+export function resolveCompiledMethodFromConfig(config) {
+    if (!config || typeof config !== "object")
+        return null;
+    const raw = config;
+    return resolveCompiledMethodId(raw.method);
+}
+export function resolveRequiredCompiledMethodFromConfig(config, label = "compiled config") {
+    const methodId = resolveCompiledMethodFromConfig(config);
+    if (!methodId) {
+        throw new Error(`Missing or invalid Method in ${label}.`);
+    }
+    return methodId;
+}
+export function formatCompiledMethodStageStep(methodId, stage, options = {}) {
+    return formatMethodStageStep(getCompiledMethod(methodId, options), stage);
+}
+function resolveMethodDefinitionForStageMetadata(methodId, sourcePath) {
+    if (sourcePath &&
+        existsSync(join(methodPackagePathForCompiled(sourcePath), "method.json"))) {
+        return getActiveCompiledMethod(sourcePath);
+    }
+    return getCompiledMethod(methodId, { sourcePath });
+}
+function formatMethodStageStep(method, stage) {
+    const stageIndex = method.stages.findIndex((candidate) => candidate.id === stage);
+    if (stageIndex === -1) {
+        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
+    }
+    const stageDefinition = method.stages[stageIndex];
+    if (!stageDefinition) {
+        throw new Error(`Stage "${stage}" is not part of the compiled runtime.`);
+    }
+    return `Stage ${stageIndex + 1}/${method.stages.length} - ${stageDefinition.label}`;
+}
+export function getMethodStageDefinition(methodId, stage, sourcePath) {
+    const method = resolveMethodDefinitionForStageMetadata(methodId, sourcePath);
+    return method.stages.find((candidate) => candidate.id === stage) ?? null;
+}
+export function getMethodStagePosition(methodId, stage, sourcePath) {
+    const stages = getMethodStages(methodId, sourcePath);
+    const stageIndex = stages.findIndex((candidate) => candidate === stage);
+    if (stageIndex === -1)
+        return null;
+    return {
+        stageIndex: stageIndex + 1,
+        stageTotal: stages.length,
+        stages: [...stages],
+    };
+}
+export function getMethodStages(methodId, sourcePath) {
+    return resolveMethodDefinitionForStageMetadata(methodId, sourcePath).stages.map((definition) => definition.id);
+}
+export function getActiveCompiledStages(compiledPath) {
+    return getActiveCompiledMethod(compiledPath).stages.map((definition) => definition.id);
+}
+export function getMethodStagePolicyNotes(methodId, stage, sourcePath) {
+    const method = resolveMethodDefinitionForStageMetadata(methodId, sourcePath);
+    return [...(method.stagePolicyNotes?.[stage] ?? [])];
+}
+export function getActiveCompiledStagePolicyNotes(compiledPath, stage) {
+    const method = getActiveCompiledMethod(compiledPath);
+    return [...(method.stagePolicyNotes?.[stage] ?? [])];
+}
+export function resolveActiveCompiledStageAcceptance(compiledPath, stage) {
+    return getActiveCompiledMethod(compiledPath).stages.find((candidate) => candidate.id === stage)?.acceptance;
+}
+export function formatActiveCompiledMethodStageStep(compiledPath, stage) {
+    return formatMethodStageStep(getActiveCompiledMethod(compiledPath), stage);
+}

package/dist/packages/{workflow-package/workflow-helpers.d.ts → method-package/method-helpers.d.ts}

@@ -1,17 +1,17 @@
 import { type LocalInstructionMode, type RuntimeInstructionMode, type RuntimeStageInstructions } from "../compiler/lib/schema.js";
-import { type WorkflowStageDefinition } from "./workflow-definitions.js";
-export interface WorkflowReporter {
+import { type MethodStageDefinition } from "./method-definitions.js";
+export interface MethodReporter {
     line?: (message: string) => void;
     blankLine?: () => void;
 }
-export interface WorkflowStageResult {
+export interface MethodStageResult {
     ok: boolean;
     code: number;
     summary?: string | null;
 }
-export declare function workflowQueryDirectory(): string;
-export declare function workflowImproveDirectory(): string;
-export declare function workflowCompileStageDirectory(stageDir: string): string;
+export declare function methodQueryDirectory(): string;
+export declare function methodImproveDirectory(): string;
+export declare function methodCompileStageDirectory(stageDir: string): string;
 export interface LocalSkillContractExtension {
     reads: string[];
     count: number;
@@ -25,10 +25,10 @@ export declare function buildLocalSkillContractExtension(rootPath: string, direc
 export declare function buildLocalSkillContractExtensionRelativeTo(rootPath: string, relativeToPath: string, directories: string[], purpose: string): LocalSkillContractExtension;
 export declare function mergeLocalSkillContractExtensions(extensions: LocalSkillContractExtension[]): LocalSkillContractExtension;
 export declare function buildStageInstructions(stageSkillDir: string, localSkills: LocalSkillContractExtension): RuntimeStageInstructions;
-export declare function reportLine(reporter: WorkflowReporter | undefined, message: string): void;
-export declare function reportBlankLine(reporter: WorkflowReporter | undefined): void;
-export declare function reportValidationFailure(reporter: WorkflowReporter | undefined, summary: string, errors?: string[]): void;
-export declare function resolveStageAcceptance(workflowId: string, stageId: string, sourcePath?: string): WorkflowStageDefinition["acceptance"] | undefined;
+export declare function reportLine(reporter: MethodReporter | undefined, message: string): void;
+export declare function reportBlankLine(reporter: MethodReporter | undefined): void;
+export declare function reportValidationFailure(reporter: MethodReporter | undefined, summary: string, errors?: string[]): void;
+export declare function resolveStageAcceptance(methodId: string, stageId: string, sourcePath?: string): MethodStageDefinition["acceptance"] | undefined;
 export declare function validateStageOutcome(_dirPath: string, validation: {
     ok: boolean;
     summary: string;

package/dist/packages/{workflow-package/workflow-helpers.js → method-package/method-helpers.js}

@@ -3,16 +3,16 @@ import { join, relative, sep } from "node:path";
 import { listFilesRecursive } from "../shared/filesystem.js";
 import { parseJsonFrontmatter } from "../shared/parse.js";
 import { isMarkdownFile } from "../shared/file-types.js";
-import { getCompiledWorkflow, } from "./workflow-definitions.js";
-import { COMPILED_METHOD_DIR, workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { getCompiledMethod, } from "./method-definitions.js";
+import { COMPILED_METHOD_DIR, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
 const LOCAL_SKILL_READ_LIMIT = 50;
-export function workflowQueryDirectory() {
+export function methodQueryDirectory() {
     return `${COMPILED_METHOD_DIR}/use/query`;
 }
-export function workflowImproveDirectory() {
+export function methodImproveDirectory() {
     return `${COMPILED_METHOD_DIR}/improve`;
 }
-export function workflowCompileStageDirectory(stageDir) {
+export function methodCompileStageDirectory(stageDir) {
     return `${COMPILED_METHOD_DIR}/compile/stages/${stageDir}`;
 }
 export function emptyLocalSkillContractExtension() {
@@ -40,10 +40,10 @@ function collectLocalSkillDocs(rootPath, directories) {
 }
 function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories) {
     const docs = new Map();
-    const workflowRoot = workflowPackagePathForCompiled(rootPath);
-    const rootReadme = join(workflowRoot, "README.md");
+    const methodRoot = methodPackagePathForCompiled(rootPath);
+    const rootReadme = join(methodRoot, "README.md");
     if (existsSync(rootReadme)) {
-        const read = projectWorkflowReadPath(rootPath, relativeToPath, rootReadme);
+        const read = projectMethodReadPath(rootPath, relativeToPath, rootReadme);
         docs.set(read, {
             read,
             absolutePath: rootReadme,
@@ -53,7 +53,7 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
     for (const directory of directories) {
         const absoluteDirectory = resolveAuthoringDirectory(rootPath, directory);
         for (const filePath of listFilesRecursive(absoluteDirectory, isMarkdownFile)) {
-            const read = projectWorkflowReadPath(rootPath, relativeToPath, filePath);
+            const read = projectMethodReadPath(rootPath, relativeToPath, filePath);
             docs.set(read, {
                 read,
                 absolutePath: filePath,
@@ -66,25 +66,21 @@ function collectLocalSkillDocsRelativeTo(rootPath, relativeToPath, directories)
         .slice(0, LOCAL_SKILL_READ_LIMIT);
 }
 function resolveAuthoringDirectory(rootPath, directory) {
-    if (directory === COMPILED_METHOD_DIR || directory === "workflow") {
-        return workflowPackagePathForCompiled(rootPath);
+    if (directory === COMPILED_METHOD_DIR) {
+        return methodPackagePathForCompiled(rootPath);
     }
     if (directory.startsWith(`${COMPILED_METHOD_DIR}${sep}`) || directory.startsWith(`${COMPILED_METHOD_DIR}/`)) {
         const relativeMethodPath = directory.replace(/^method[\\/]/, "");
-        return join(workflowPackagePathForCompiled(rootPath), relativeMethodPath);
-    }
-    if (directory.startsWith(`workflow${sep}`) || directory.startsWith("workflow/")) {
-        const relativeWorkflowPath = directory.replace(/^workflow[\\/]/, "");
-        return join(workflowPackagePathForCompiled(rootPath), relativeWorkflowPath);
+        return join(methodPackagePathForCompiled(rootPath), relativeMethodPath);
     }
     return join(rootPath, directory);
 }
-function projectWorkflowReadPath(rootPath, relativeToPath, absolutePath) {
-    const workflowRoot = workflowPackagePathForCompiled(rootPath);
-    const normalizedWorkflowRoot = `${workflowRoot}${sep}`;
-    if (absolutePath === workflowRoot || absolutePath.startsWith(normalizedWorkflowRoot)) {
-        const relativeWorkflowPath = relative(workflowRoot, absolutePath);
-        return relative(relativeToPath, join(rootPath, COMPILED_METHOD_DIR, relativeWorkflowPath));
+function projectMethodReadPath(rootPath, relativeToPath, absolutePath) {
+    const methodRoot = methodPackagePathForCompiled(rootPath);
+    const normalizedMethodRoot = `${methodRoot}${sep}`;
+    if (absolutePath === methodRoot || absolutePath.startsWith(normalizedMethodRoot)) {
+        const relativeMethodPath = relative(methodRoot, absolutePath);
+        return relative(relativeToPath, join(rootPath, COMPILED_METHOD_DIR, relativeMethodPath));
     }
     return relative(relativeToPath, absolutePath);
 }
@@ -116,8 +112,8 @@ function buildContractExtensionFromDocs(docs, directories, purpose) {
         notes: [
             readNotice,
             localMode === "override"
-                ? `${purpose} One or more local docs declare \`mode: override\`, so their workflow instructions replace Interf's bundled stage instructions for this run. They still do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`
-                : `${purpose} These local workflow docs can refine the stage, but they do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`,
+                ? `${purpose} One or more local docs declare \`mode: override\`, so their Method instructions replace Interf's bundled stage instructions for this run. They still do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`
+                : `${purpose} These local Method docs can refine the stage, but they do not bypass coverage proof, evidence weighting, required writes, or deterministic runtime reconciliation.`,
         ],
         localMode,
         effectiveMode: localMode ?? "builtin",
@@ -163,8 +159,8 @@ export function reportValidationFailure(reporter, summary, errors = []) {
         reportLine(reporter, `- ${error}`);
     }
 }
-export function resolveStageAcceptance(workflowId, stageId, sourcePath) {
-    return getCompiledWorkflow(workflowId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
+export function resolveStageAcceptance(methodId, stageId, sourcePath) {
+    return getCompiledMethod(methodId, { sourcePath }).stages.find((stage) => stage.id === stageId)?.acceptance;
 }
 export function validateStageOutcome(_dirPath, validation) {
     return validation;

package/dist/packages/method-package/method-review-paths.d.ts

@@ -0,0 +1,10 @@
+import type { MethodImprovementContext } from "../compiler/lib/schema.js";
+export interface MethodImprovementReviewSourcePaths {
+    compiledRuntime: string | null;
+    testComparisons: string | null;
+    executionShells: string | null;
+    targetTestRuns: string | null;
+    targetTestSandboxes: string | null;
+}
+export declare function resolveMethodImprovementReviewSourcePaths(compiledPath: string): MethodImprovementReviewSourcePaths;
+export declare function resolveMethodImprovementReviewPaths(compiledPath: string): MethodImprovementContext["review_paths"];

package/dist/packages/{workflow-package/workflow-review-paths.js → method-package/method-review-paths.js}

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { testRootForCompiled, targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, stageExecutionShellsRoot, compiledRuntimeRoot, } from "../compiler/compiled-paths.js";
-export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
+export function resolveMethodImprovementReviewSourcePaths(compiledPath) {
     const compiledRuntime = compiledRuntimeRoot(compiledPath);
     const testComparisons = testRootForCompiled(compiledPath);
     const executionShells = stageExecutionShellsRoot(compiledPath);
@@ -18,10 +18,10 @@ export function resolveWorkflowImprovementReviewSourcePaths(compiledPath) {
         targetTestSandboxes: existsSync(targetTestSandboxes) ? targetTestSandboxes : null,
     };
 }
-export function resolveWorkflowImprovementReviewPaths(compiledPath) {
-    const sources = resolveWorkflowImprovementReviewSourcePaths(compiledPath);
+export function resolveMethodImprovementReviewPaths(compiledPath) {
+    const sources = resolveMethodImprovementReviewSourcePaths(compiledPath);
     return {
-        workflow_root: "workflow",
+        method_root: "method",
         compiled_runtime: sources.compiledRuntime ? "artifacts/compiled-runtime" : null,
         test_comparisons: sources.testComparisons ? "artifacts/test-comparisons" : null,
         execution_shells: sources.executionShells ? "artifacts/execution-shells" : null,

package/dist/packages/{workflow-package/workflow-stage-runner.d.ts → method-package/method-stage-runner.d.ts}

@@ -1,25 +1,26 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
-import { type RuntimeContractType, type RuntimeStageInstructions } from "../compiler/lib/schema.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
+import { type RuntimeStageInstructions } from "../compiler/lib/schema.js";
+import type { RuntimeContractType } from "../contracts/lib/schema.js";
 import { type RuntimeStageContractDraft } from "../compiler/runtime.js";
-import { type WorkflowReporter, type WorkflowStageResult } from "./workflow-helpers.js";
-interface WorkflowStageShape<TContractType extends RuntimeContractType> {
+import { type MethodReporter, type MethodStageResult } from "./method-helpers.js";
+interface MethodStageShape<TContractType extends RuntimeContractType> {
     id: string;
     label: string;
     contractType: TContractType;
 }
 interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType> {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
     executionPath?: string;
     targetName: string;
-    workflow: string;
-    workflowSourcePath?: string;
-    stageDefinition: WorkflowStageShape<TContractType>;
+    method: string;
+    methodSourcePath?: string;
+    stageDefinition: MethodStageShape<TContractType>;
     instructions: RuntimeStageInstructions;
     summary: string;
     contract: RuntimeStageContractDraft;
     statusLines: string[];
-    reporter?: WorkflowReporter;
+    reporter?: MethodReporter;
     completionCheck?: (() => boolean) | null;
     onStatus?: (line: string) => void;
     syncWrites?: (() => void) | null;
@@ -37,6 +38,6 @@ interface ExecuteValidatedSummarizeStageOptions<TContractType extends RuntimeCon
 export declare function findStageByContractType<TStage extends {
     contractType: string;
 }>(stages: TStage[], contractType: TStage["contractType"]): TStage;
-export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<WorkflowStageResult>;
-export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<WorkflowStageResult>;
+export declare function executeValidatedStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedStageOptions<TContractType>): Promise<MethodStageResult>;
+export declare function executeValidatedSummarizeStage<TContractType extends RuntimeContractType>(options: ExecuteValidatedSummarizeStageOptions<TContractType>): Promise<MethodStageResult>;
 export {};

package/dist/packages/{workflow-package/workflow-stage-runner.js → method-package/method-stage-runner.js}

@@ -1,9 +1,9 @@
 import { markRuntimeRunSucceededAfterValidation, buildStagePrompt, markRuntimeRunFailedAfterValidation, runExecutorStage, runExecutorSummarizeStage, } from "../compiler/runtime.js";
-import { reportValidationFailure, validateStageOutcome, } from "./workflow-helpers.js";
+import { reportValidationFailure, validateStageOutcome, } from "./method-helpers.js";
 export function findStageByContractType(stages, contractType) {
     const stage = stages.find((candidate) => candidate.contractType === contractType);
     if (!stage) {
-        throw new Error(`Missing workflow stage for contract type: ${contractType}`);
+        throw new Error(`Missing method stage for contract type: ${contractType}`);
     }
     return stage;
 }
@@ -20,8 +20,8 @@ export async function executeValidatedStage(options) {
         compiledPath: options.compiledPath,
         executionPath: options.executionPath,
         compiledName: options.targetName,
-        workflow: options.workflow,
-        workflowSourcePath: options.workflowSourcePath,
+        method: options.method,
+        methodSourcePath: options.methodSourcePath,
         stage: options.stageDefinition.id,
         stageLabel: options.stageDefinition.label,
         contractType: options.stageDefinition.contractType,
@@ -46,8 +46,8 @@ export async function executeValidatedSummarizeStage(options) {
         compiledPath: options.compiledPath,
         executionPath: options.executionPath,
         compiledName: options.targetName,
-        workflow: options.workflow,
-        workflowSourcePath: options.workflowSourcePath,
+        method: options.method,
+        methodSourcePath: options.methodSourcePath,
         stage: options.stageDefinition.id,
         stageLabel: options.stageDefinition.label,
         contractType: options.stageDefinition.contractType,

package/dist/packages/methods/index.d.ts

@@ -0,0 +1,2 @@
+export * as methodResolution from "./method-resolution.js";
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveMethodId, } from "./method-resolution.js";

package/dist/packages/methods/index.js

@@ -0,0 +1,2 @@
+export * as methodResolution from "./method-resolution.js";
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, resolveMethodId, } from "./method-resolution.js";

package/dist/packages/methods/method-resolution.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_METHOD_ID = "interf-default";
+export interface MethodSelectionLike {
+    method?: string | null;
+}
+export declare function methodIdForSourcePreparationConfig(preparationConfig: MethodSelectionLike | null | undefined): string | null;
+export declare function resolveMethodId(selection: MethodSelectionLike | null | undefined, fallback?: string): string;

package/dist/packages/methods/method-resolution.js

@@ -0,0 +1,7 @@
+export const DEFAULT_METHOD_ID = "interf-default";
+export function methodIdForSourcePreparationConfig(preparationConfig) {
+    return preparationConfig?.method ?? null;
+}
+export function resolveMethodId(selection, fallback = DEFAULT_METHOD_ID) {
+    return methodIdForSourcePreparationConfig(selection) ?? fallback;
+}

package/dist/packages/project-model/index.d.ts

@@ -5,8 +5,5 @@ export * as interf from "./interf.js";
 export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
-export * as compiledPaths from "./compiled-paths.js";
 export * as projectPaths from "./project-paths.js";
-export * as compiledRaw from "./compiled-raw.js";
-export * as compiledReset from "./compiled-reset.js";
-export type { InterfConfig, MethodId, PreparationName, SourceDatasetConfig, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";
+export type { InterfConfig, MethodId, PreparationName, SourceFolderBinding, SourcePreparationConfig, SourceReadinessCheck, SourceFolderConfig, } from "./lib/schema.js";

package/dist/packages/project-model/index.js

@@ -5,7 +5,4 @@ export * as interf from "./interf.js";
 export * as detect from "./interf-detect.js";
 export * as bootstrap from "./interf-bootstrap.js";
 export * as scaffold from "./interf-scaffold.js";
-export * as compiledPaths from "./compiled-paths.js";
 export * as projectPaths from "./project-paths.js";
-export * as compiledRaw from "./compiled-raw.js";
-export * as compiledReset from "./compiled-reset.js";

package/dist/packages/project-model/interf-detect.d.ts

@@ -7,13 +7,9 @@ export interface ResolvedCompiled {
 }
 export declare const INTERF_CONTAINER_NAME = "interf";
 export declare const METHOD_CONTAINER_NAME = "methods";
-export declare const WORKFLOW_CONTAINER_NAME = "methods";
-export declare const LEGACY_WORKFLOW_CONTAINER_NAME = "workflows";
 export declare const TEST_CONTAINER_NAME = "tests";
 export declare const INTERF_CONFIG_FILE = "interf.json";
 export declare const METHOD_PACKAGE_DIR = "method";
-export declare const WORKFLOW_PACKAGE_DIR = "method";
-export declare const LEGACY_WORKFLOW_PACKAGE_DIR = "workflow";
 export declare function readInterfConfig(dirPath: string): InterfConfig | null;
 export declare function hasSourceFolderInput(config: InterfConfig | null | undefined): config is InterfConfig & {
     source: {
@@ -28,7 +24,7 @@ export declare function resolveCompiled(cwd: string): ResolvedCompiled | null;
 export declare function resolveSourceFolderPath(compiledPath: string, config?: InterfConfig | null): string;
 export declare function resolveSourceControlPath(compiledPath: string): string;
 export declare function resolveSourceInputPath(compiledPath: string): string;
-export declare function listCompiledDatasetsForSourceFolder(sourcePath: string): Array<{
+export declare function listPortableContextsForSourceFolder(sourcePath: string): Array<{
     path: string;
     config: InterfConfig;
 }>;

package/dist/packages/project-model/interf-detect.js

@@ -2,19 +2,15 @@ import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { warnInterf } from "../shared/logger.js";
 import { readJsonFileUnchecked } from "../shared/parse.js";
-import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
+import { portableContextPath, projectInterfRoot, } from "./project-paths.js";
 import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
 import { InterfConfigSchema, } from "./lib/schema.js";
 import { assertPathWithinRoot } from "../shared/path-guards.js";
 export const INTERF_CONTAINER_NAME = "interf";
 export const METHOD_CONTAINER_NAME = "methods";
-export const WORKFLOW_CONTAINER_NAME = METHOD_CONTAINER_NAME;
-export const LEGACY_WORKFLOW_CONTAINER_NAME = "workflows";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
 export const METHOD_PACKAGE_DIR = "method";
-export const WORKFLOW_PACKAGE_DIR = METHOD_PACKAGE_DIR;
-export const LEGACY_WORKFLOW_PACKAGE_DIR = "workflow";
 export function readInterfConfig(dirPath) {
     const configPath = compiledInterfConfigPath(dirPath);
     if (!existsSync(configPath))
@@ -67,17 +63,13 @@ export function resolveSourceInputPath(compiledPath) {
     const config = readInterfConfig(compiledPath);
     const sourceBinding = typeof config?.source?.preparation_path === "string" && config.source.preparation_path.length > 0
         ? config.source.preparation_path
-        : typeof config?.source?.source_folder_path === "string" && config.source.source_folder_path.length > 0
-            ? config.source.source_folder_path
-            : typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0
-                ? config.source.dataset_path
-                : null;
+        : null;
     if (sourceBinding) {
         return resolve(compiledPath, sourceBinding);
     }
     throw new Error(`Portable context is missing source.preparation_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
-export function listCompiledDatasetsForSourceFolder(sourcePath) {
+export function listPortableContextsForSourceFolder(sourcePath) {
     const interfRoot = projectInterfRoot(sourcePath);
     if (!existsSync(interfRoot))
         return [];
@@ -91,11 +83,10 @@ export function listCompiledDatasetsForSourceFolder(sourcePath) {
     }
     return readdirSync(interfRoot)
         .filter((entry) => !entry.startsWith(".") &&
-        entry !== WORKFLOW_CONTAINER_NAME &&
-        entry !== LEGACY_WORKFLOW_CONTAINER_NAME &&
+        entry !== METHOD_CONTAINER_NAME &&
         entry !== TEST_CONTAINER_NAME &&
         entry !== INTERF_CONFIG_FILE)
-        .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
+        .map((entry) => portableContextPath(sourcePath, entry))
         .filter((compiledPath) => existsSync(compiledPath))
         .map((compiledPath) => {
         const config = readInterfConfig(compiledPath);
@@ -123,8 +114,7 @@ export function assertCompiledContainer(sourcePath) {
                     return true;
                 }
             }
-            if (entry === WORKFLOW_CONTAINER_NAME ||
-                entry === LEGACY_WORKFLOW_CONTAINER_NAME ||
+            if (entry === METHOD_CONTAINER_NAME ||
                 entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
@@ -167,8 +157,7 @@ export function assertCompiledContainer(sourcePath) {
                 return true;
             }
         }
-        if (entry === WORKFLOW_CONTAINER_NAME ||
-            entry === LEGACY_WORKFLOW_CONTAINER_NAME ||
+        if (entry === METHOD_CONTAINER_NAME ||
             entry === TEST_CONTAINER_NAME)
             return false;
         const entryPath = join(containerPath, entry);

package/dist/packages/project-model/interf-scaffold.d.ts

@@ -1,3 +1,3 @@
-export declare function ensurePortableContextScaffold(sourcePath: string, datasetName: string, workflowId?: string): string;
-export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function ensurePortableContextScaffold(sourcePath: string, preparationName: string, methodId?: string): string;
+export declare function createCompiled(name: string, sourcePath: string, methodId?: string, about?: string, sourceFolderPath?: string): string;
 export declare function defaultCompiledNameForSource(sourcePath: string): string;