@interf/compiler 0.7.3 → 0.9.3

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

@@ -0,0 +1,116 @@
+import { rmSync } from "node:fs";
+import { createMethodAuthoringShell } from "../agents/lib/shells.js";
+import { createScratchLocalMethodPackage } from "../method-package/interf-method-package.js";
+import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
+import { loadMethodDefinitionFromDir, validateMethodPackage, methodDefinitionPath, } from "../method-package/local-methods.js";
+import { runMethodEditSession } from "./method-edit-session.js";
+function buildMethodAuthoringPrompt() {
+    return [
+        "This is an automated Interf Method-authoring run, not an open-ended chat session.",
+        "Execute it now.",
+        "Create one standalone Method package for the source data, desired portable-context outputs, and proof requirements in this source folder.",
+        "Read `runtime/authoring-context.json` first.",
+        "Treat `task_prompt` as the user's preparation-and-evidence brief: source data, output shape, and evidence that should show the data is ready.",
+        `Then read \`method/README.md\`, \`method/method.json\`, and \`method/${CONTEXT_INTERFACE_FILE}\`.`,
+        "The `method/` directory starts as a neutral Method package scaffold, not as a suggested Method.",
+        "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the Method this agent work actually needs.",
+        "Review `artifacts/source-folder/raw/` before editing the package.",
+        "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
+        "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
+        "Edit only files under `method/`.",
+        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
+        "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
+        "Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+        "Do not preserve the placeholder `prepare` stage unless the final Method genuinely needs a stage with that exact role.",
+        "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
+        "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
+        "For file output zones that replace scaffold files, add `artifacts_must_not_contain` entries that reject `Not yet compiled.` placeholder text; its keys must be artifact paths like `home.md`, not zone ids like `home`.",
+        "Before stopping, verify every zone-count acceptance key is declared in `method.schema.json`.",
+        "For every stage in `method.json`, create `method/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's kebab-case `skill_dir`.",
+        "Every zone path in `method.schema.json` must be unique and non-overlapping. Do not declare both `knowledge/indexes` and `knowledge/indexes/some-file.md` as separate zones.",
+        "Make the package materially specific to this Preparation task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
+        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
+        "Keep the portable-context entrypoint canonical: if the Method writes an agent entrypoint, declare zone id `home` with path `home.md` and make the final shaping stage own it.",
+        "Do not move the main entrypoint to `knowledge/home.md` or any other nested path.",
+        "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
+        "Do not introduce wikilinks unless the Method also creates the target note by exact basename or explicit relative path.",
+        "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
+        "Do not make one stage point at files or notes that are only created later by another stage.",
+        "Prefer conservative retrieval routing over speculative note sprawl.",
+        "Do not narrate plans or ask follow-up questions.",
+        "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
+        "As soon as the Method edits are complete, stop.",
+    ].join("\n");
+}
+function validateAuthoredMethodPackage(methodPath) {
+    const validation = validateMethodPackage(methodPath);
+    if (!validation.ok)
+        return validation;
+    const definition = loadMethodDefinitionFromDir(methodPath);
+    if (!definition)
+        return validation;
+    const errors = [...validation.errors];
+    const placeholderStage = definition.stages?.find((stage) => stage.id === "prepare" &&
+        stage.contract_type === "method-draft-stage" &&
+        stage.writes.includes("draft-context"));
+    const placeholderZone = definition.method_schema.zones.find((zone) => zone.id === "draft-context");
+    const placeholderPurpose = definition.purpose?.label === "From-scratch Method draft" ||
+        definition.purpose?.task_hint?.includes("Replace this neutral scaffold");
+    if (placeholderStage) {
+        errors.push("Authored Method still contains the neutral scaffold stage `prepare`.");
+    }
+    if (placeholderZone) {
+        errors.push("Authored Method still contains the neutral scaffold zone `draft-context`.");
+    }
+    if (placeholderPurpose) {
+        errors.push("Authored Method still contains the neutral scaffold purpose.");
+    }
+    return {
+        ok: validation.ok && errors.length === 0,
+        summary: errors.length === 0
+            ? validation.summary
+            : `Method package has ${errors.length} issue(s).`,
+        errors,
+        counts: validation.counts,
+    };
+}
+export async function runMethodAuthoringDraft(options) {
+    const methodPath = createScratchLocalMethodPackage({
+        sourcePath: options.sourcePath,
+        methodId: options.methodId,
+        label: options.label,
+        hint: options.hint,
+    });
+    const shell = createMethodAuthoringShell({
+        methodPath,
+        methodId: options.methodId,
+        label: options.label,
+        referenceMethodId: options.baseMethodId ?? null,
+        sourceFolderPath: options.sourceFolderPath,
+        taskPrompt: options.taskPrompt,
+        checks: options.checks ?? [],
+    });
+    const session = await runMethodEditSession({
+        executor: options.executor,
+        methodPath,
+        shell,
+        prompt: buildMethodAuthoringPrompt(),
+        validate: validateAuthoredMethodPackage,
+        maxValidationRepairAttempts: 1,
+        onStatus: options.onStatus,
+    });
+    if (session.status !== "updated") {
+        rmSync(methodPath, { recursive: true, force: true });
+    }
+    return {
+        status: session.status,
+        changed: session.changed,
+        summary: session.summary,
+        validation: session.validation,
+        methodPath,
+        shellPath: shell.rootPath,
+    };
+}
+export function resolveMethodDraftPath(sourcePath, methodId) {
+    return methodDefinitionPath(sourcePath, methodId);
+}

package/dist/packages/method-authoring/method-edit-session.d.ts

@@ -0,0 +1,18 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { MethodValidationResult } from "../method-package/local-methods.js";
+import { type MethodEditShellArtifacts } from "./lib/method-edit-utils.js";
+export interface MethodEditSessionResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: MethodValidationResult | null;
+    summary: string;
+}
+export declare function runMethodEditSession(options: {
+    executor: MethodExecutor;
+    methodPath: string;
+    shell: MethodEditShellArtifacts;
+    prompt: string;
+    validate: (methodPath: string) => MethodValidationResult;
+    maxValidationRepairAttempts?: number;
+    onStatus?: (line: string) => void;
+}): Promise<MethodEditSessionResult>;

package/dist/packages/method-authoring/method-edit-session.js

@@ -0,0 +1,125 @@
+import { appendFileSync, existsSync, realpathSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { copyDirectory, directoriesMatch, } from "./lib/method-edit-utils.js";
+export async function runMethodEditSession(options) {
+    const editableMethodPath = join(options.shell.rootPath, "method");
+    copyDirectory(options.methodPath, options.shell.methodBeforePath);
+    if (!existsSync(editableMethodPath)) {
+        copyDirectory(options.methodPath, editableMethodPath);
+    }
+    writeFileSync(options.shell.promptLogPath, `${options.prompt}\n`);
+    const maxValidationRepairAttempts = options.maxValidationRepairAttempts ?? 0;
+    let prompt = options.prompt;
+    for (let attempt = 0; attempt <= maxValidationRepairAttempts; attempt += 1) {
+        let code = 1;
+        let executeError = null;
+        try {
+            code = await options.executor.execute(options.shell.rootPath, prompt, {
+                eventLogPath: options.shell.eventLogPath,
+                statusLogPath: options.shell.statusLogPath,
+                completionCheck: () => {
+                    try {
+                        if (directoriesMatch(options.shell.methodBeforePath, editableMethodPath))
+                            return false;
+                        return options.validate(editableMethodPath).ok;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                onStatus: options.onStatus,
+            });
+        }
+        catch (error) {
+            executeError = error instanceof Error ? error.message : String(error);
+        }
+        copyDirectory(editableMethodPath, options.shell.methodAfterPath);
+        const changed = !directoriesMatch(options.shell.methodBeforePath, options.shell.methodAfterPath);
+        if (executeError) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "executor-failed",
+                changed,
+                validation: null,
+                summary: `Method editor failed before completing: ${executeError}`,
+            };
+        }
+        if (code !== 0) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "executor-failed",
+                changed,
+                validation: null,
+                summary: `Method editor exited with code ${code}.`,
+            };
+        }
+        const validation = options.validate(editableMethodPath);
+        if (validation.ok) {
+            if (!sameRealPath(editableMethodPath, options.methodPath)) {
+                copyDirectory(editableMethodPath, options.methodPath);
+            }
+            return {
+                status: changed ? "updated" : "no-change",
+                changed,
+                validation,
+                summary: changed
+                    ? "Method package updated and validated."
+                    : "Method package is valid without additional edits.",
+            };
+        }
+        const details = validation.errors.length > 0
+            ? `: ${validation.errors.slice(0, 6).join("; ")}`
+            : "";
+        if (!changed || attempt >= maxValidationRepairAttempts) {
+            copyDirectory(options.shell.methodBeforePath, options.methodPath);
+            copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+            return {
+                status: "invalid",
+                changed,
+                validation,
+                summary: changed
+                    ? `Method package failed validation: ${validation.summary}${details}`
+                    : `Method package is invalid without any Method edits: ${validation.summary}${details}`,
+            };
+        }
+        prompt = [
+            "This is an automated Interf Method validation-repair pass.",
+            "The previous edit did not pass package validation.",
+            "Fix only the validation errors below. Do not redesign the Method.",
+            "",
+            "Validation errors:",
+            ...validation.errors.slice(0, 12).map((error) => `- ${error}`),
+            "",
+            "Rules:",
+            "- Edit only files under `method/`.",
+            "- Use kebab-case ids everywhere: stage ids, skill_dir values, zone ids, reads/writes values, and package ids. Never use underscores.",
+            "- Keep every stage `skill_dir` matched by `method/compile/stages/<skill_dir>/SKILL.md`.",
+            "- Keep `method.schema.json` zone paths unique and non-overlapping.",
+            "- Keep zone-count acceptance keys declared in `method.schema.json`.",
+            "- Keep `artifacts_must_not_contain` keys as portable-context relative artifact paths such as `home.md`, not zone ids.",
+            "- Preserve root `home.md` as the main portable-context entrypoint when the Method writes an entrypoint.",
+            "- Stop as soon as the package should validate.",
+        ].join("\n");
+        appendFileSync(options.shell.promptLogPath, `\n\n---\n\n${prompt}\n`);
+    }
+    copyDirectory(options.shell.methodBeforePath, options.methodPath);
+    copyDirectory(options.shell.methodBeforePath, editableMethodPath);
+    return {
+        status: "invalid",
+        changed: true,
+        validation: null,
+        summary: "Method package failed validation.",
+    };
+}
+function sameRealPath(leftPath, rightPath) {
+    try {
+        return existsSync(leftPath) &&
+            existsSync(rightPath) &&
+            realpathSync(leftPath) === realpathSync(rightPath);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/packages/method-authoring/method-improvement.d.ts

@@ -0,0 +1,23 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import { type MethodValidationResult } from "../method-package/local-methods.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import type { MethodImprovementLoopSummary } from "../compiler/lib/schema.js";
+export interface MethodImprovementRunResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    validation: MethodValidationResult | null;
+    summary: string;
+    shellPath: string;
+    loopRootPath: string;
+}
+export declare function runMethodImprovementLoop(options: {
+    executor: MethodExecutor;
+    compiledPath: string;
+    methodId: string;
+    compiledConfig: Pick<SourcePreparationConfig, "checks">;
+    runId: string;
+    loopIndex: number;
+    maxLoops: number;
+    maxAttempts: number;
+    previousVariations: MethodImprovementLoopSummary[];
+}): Promise<MethodImprovementRunResult>;

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

@@ -1,15 +1,15 @@
 import { appendFileSync, existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { join, relative } from "node:path";
-import { createWorkflowImprovementShell, freezeWorkflowImprovementShell, } from "../agents/lib/shells.js";
-import { validateWorkflowPackage } from "../workflow-package/local-workflows.js";
-import { CONTEXT_INTERFACE_FILE } from "../workflow-package/context-interface.js";
+import { createMethodImprovementShell, freezeMethodImprovementShell, } from "../agents/lib/shells.js";
+import { validateMethodPackage } from "../method-package/local-methods.js";
+import { CONTEXT_INTERFACE_FILE } from "../method-package/context-interface.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { resolveWorkflowImprovementReviewPaths } from "../workflow-package/workflow-review-paths.js";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, workflowImprovementRunRoot, workflowPackagePathForCompiled, } from "../compiler/compiled-paths.js";
+import { resolveMethodImprovementReviewPaths } from "../method-package/method-review-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, methodImprovementRunRoot, methodPackagePathForCompiled, } from "../compiler/compiled-paths.js";
 import { readInterfConfig } from "../project-model/interf.js";
 import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { WorkflowImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
-import { runWorkflowEditSession } from "./workflow-edit-session.js";
+import { MethodImprovementRunLedgerSchema, } from "../compiler/lib/schema.js";
+import { runMethodEditSession } from "./method-edit-session.js";
 function toShellArtifactPath(absolutePath, sourceRoot, shellRoot) {
     if (!absolutePath)
         return null;
@@ -33,16 +33,16 @@ function buildLoopContext(options) {
     const previousVariations = options.previousVariations.map((summary) => mapLoopSummaryForShell(summary, options.compiledPath));
     const latestFailure = previousVariations.at(-1) ?? null;
     return {
-        kind: "interf-workflow-improvement-loop",
+        kind: "interf-method-improvement-loop",
         version: 1,
         generated_at: new Date().toISOString(),
         target_name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         loop_index: options.loopIndex,
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
-        review_paths: resolveWorkflowImprovementReviewPaths(options.compiledPath),
-        truth_checks: {
+        review_paths: resolveMethodImprovementReviewPaths(options.compiledPath),
+        readiness_checks: {
             count: options.compiledConfig.checks.length,
             questions: options.compiledConfig.checks.map((check, index) => ({
                 id: check.id ?? `check-${index + 1}`,
@@ -53,86 +53,86 @@ function buildLoopContext(options) {
         latest_failure: latestFailure,
     };
 }
-function buildWorkflowImprovementPrompt() {
+function buildMethodImprovementPrompt() {
     return [
-        "This is an automated Interf workflow-improvement run, not an open-ended chat session.",
+        "This is an automated Interf Method-improvement run, not an open-ended chat session.",
         "The user already invoked this through `interf compile` with self-improving loops enabled. Execute it now.",
         "Read `runtime/loop-context.json` first.",
-        `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, \`workflow/${CONTEXT_INTERFACE_FILE}\`, and \`workflow/improve/SKILL.md\` if it exists.`,
-        "Review preserved evidence from earlier failures under `artifacts/` before you edit the workflow.",
-        "Treat `workflow/improve/SKILL.md` as guidance for how to improve the workflow, not as the default file to edit.",
-        "Treat the workflow package as four aligned layers: purpose, inputs, context interface, and stages.",
-        "Prefer editing the stage docs, workflow contract, input contract, or schema ownership that actually change compiled outputs.",
-        "Edit only files under `workflow/`.",
-        "Do not edit checks, test specs, raw dataset files, or generated compiled outputs.",
-        "Keep the workflow valid for the current compiler API and workflow schema.",
+        `Then read \`method/README.md\`, \`method/method.json\`, \`method/${CONTEXT_INTERFACE_FILE}\`, and \`method/improve/SKILL.md\` if it exists.`,
+        "Review preserved evidence from earlier failures under `artifacts/` before you edit the Method.",
+        "Treat `method/improve/SKILL.md` as guidance for how to improve the Method, not as the default file to edit.",
+        "Treat the Method package as four aligned layers: purpose, inputs, context interface, and stages.",
+        "Prefer editing the stage docs, Method contract, input contract, or schema ownership that actually change portable-context outputs.",
+        "Edit only files under `method/`.",
+        "Do not edit checks, test specs, raw source files, or generated portable-context outputs.",
+        "Keep the Method package valid for the current compiler API and `method.schema.json`.",
         "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
         "Do not make one stage point at files or notes that are only created later by another stage.",
-        "Prefer small, defensible changes to workflow docs, stage docs, stage policies, or schema ownership over random churn.",
+        "Prefer small, defensible changes to Method docs, stage docs, stage policies, or schema ownership over random churn.",
         "Do not narrate plans or ask follow-up questions.",
         "Only emit user-visible updates that begin with STATUS:, DONE:, BLOCKED:, or ERROR:.",
-        "As soon as the workflow edits are complete, stop.",
+        "As soon as the Method edits are complete, stop.",
     ].join("\n");
 }
-function updateCompiledWorkflowOrigin(options) {
+function updateCompiledMethodOrigin(options) {
     const current = readInterfConfig(options.compiledPath);
     if (!current)
         return;
     const nextConfig = {
         ...current,
-        workflow: current.workflow ?? options.selectedWorkflowId,
-        workflow_origin: {
-            selected: options.selectedWorkflowId,
+        method: current.method ?? options.selectedMethodId,
+        method_origin: {
+            selected: options.selectedMethodId,
             ...(options.localDraft ? { local_draft: true } : {}),
         },
     };
     saveCompiledInterfConfig(options.compiledPath, nextConfig);
 }
-function workflowImprovementRunLedgerPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "run.json");
+function methodImprovementRunLedgerPath(compiledPath, runId) {
+    return join(methodImprovementRunRoot(compiledPath, runId), "run.json");
 }
-function workflowImprovementLoopHistoryPath(compiledPath, runId) {
-    return join(workflowImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
+function methodImprovementLoopHistoryPath(compiledPath, runId) {
+    return join(methodImprovementRunRoot(compiledPath, runId), "loop-history.jsonl");
 }
-function workflowImprovementLoopRecordPath(loopRootPath) {
+function methodImprovementLoopRecordPath(loopRootPath) {
     return join(loopRootPath, "loop.json");
 }
-function readWorkflowImprovementRunLedger(compiledPath, runId) {
-    const ledgerPath = workflowImprovementRunLedgerPath(compiledPath, runId);
+function readMethodImprovementRunLedger(compiledPath, runId) {
+    const ledgerPath = methodImprovementRunLedgerPath(compiledPath, runId);
     if (!existsSync(ledgerPath))
         return null;
-    return readJsonFileWithSchema(ledgerPath, "workflow improvement run ledger", WorkflowImprovementRunLedgerSchema);
+    return readJsonFileWithSchema(ledgerPath, "Method improvement run ledger", MethodImprovementRunLedgerSchema);
 }
-function writeWorkflowImprovementRunLedger(compiledPath, runId, record, options) {
-    const runRoot = workflowImprovementRunRoot(compiledPath, runId);
+function writeMethodImprovementRunLedger(compiledPath, runId, record, options) {
+    const runRoot = methodImprovementRunRoot(compiledPath, runId);
     mkdirSync(runRoot, { recursive: true });
-    const existing = readWorkflowImprovementRunLedger(compiledPath, runId);
+    const existing = readMethodImprovementRunLedger(compiledPath, runId);
     const generatedAt = existing?.generated_at ?? new Date().toISOString();
     const ledger = {
-        kind: "interf-workflow-improvement-run",
+        kind: "interf-method-improvement-run",
         version: 1,
         generated_at: generatedAt,
         updated_at: new Date().toISOString(),
         run_id: runId,
         target_name: options.targetName,
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
         loops: [...(existing?.loops ?? []), record],
     };
-    writeFileSync(workflowImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
-    writeFileSync(workflowImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
-    appendFileSync(workflowImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
+    writeFileSync(methodImprovementRunLedgerPath(compiledPath, runId), `${JSON.stringify(ledger, null, 2)}\n`);
+    writeFileSync(methodImprovementLoopRecordPath(record.loop_root_path), `${JSON.stringify(record, null, 2)}\n`);
+    appendFileSync(methodImprovementLoopHistoryPath(compiledPath, runId), `${JSON.stringify(record)}\n`);
 }
-function buildWorkflowImprovementLoopRecord(options) {
+function buildMethodImprovementLoopRecord(options) {
     return {
-        kind: "interf-workflow-improvement-loop-record",
+        kind: "interf-method-improvement-loop-record",
         version: 1,
         recorded_at: new Date().toISOString(),
         run_id: options.runId,
         loop_index: options.loopIndex,
         target_name: options.targetName,
-        workflow_id: options.workflowId,
+        method_id: options.methodId,
         result: options.result,
         changed: options.changed,
         applied: options.result === "updated",
@@ -140,8 +140,8 @@ function buildWorkflowImprovementLoopRecord(options) {
         shell_path: options.shellPath,
         loop_root_path: options.loopRootPath,
         context_path: join(options.shellPath, "runtime", "loop-context.json"),
-        workflow_before_path: options.workflowBeforePath,
-        workflow_after_path: options.workflowAfterPath,
+        method_before_path: options.methodBeforePath,
+        method_after_path: options.methodAfterPath,
         prompt_log_path: options.promptLogPath,
         event_log_path: options.eventLogPath,
         status_log_path: options.statusLogPath,
@@ -149,35 +149,36 @@ function buildWorkflowImprovementLoopRecord(options) {
         validation: options.validation,
     };
 }
-export async function runWorkflowImprovementLoop(options) {
+export async function runMethodImprovementLoop(options) {
     const compiledName = readInterfConfig(options.compiledPath)?.name ?? "compiled";
     const context = buildLoopContext(options);
-    const shell = createWorkflowImprovementShell({
+    const shell = createMethodImprovementShell({
         compiledPath: options.compiledPath,
         compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         runId: options.runId,
         loopIndex: options.loopIndex,
         context,
     });
-    const workflowRoot = workflowPackagePathForCompiled(options.compiledPath);
-    const session = await runWorkflowEditSession({
+    const methodRoot = methodPackagePathForCompiled(options.compiledPath);
+    const session = await runMethodEditSession({
         executor: options.executor,
-        workflowPath: workflowRoot,
+        methodPath: methodRoot,
         shell,
-        prompt: buildWorkflowImprovementPrompt(),
-        validate: validateWorkflowPackage,
+        prompt: buildMethodImprovementPrompt(),
+        validate: validateMethodPackage,
+        maxValidationRepairAttempts: 1,
     });
-    const preservedShellManifestPath = freezeWorkflowImprovementShell(shell.rootPath);
-    writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({
+    const preservedShellManifestPath = freezeMethodImprovementShell(shell.rootPath);
+    writeMethodImprovementRunLedger(options.compiledPath, options.runId, buildMethodImprovementLoopRecord({
         targetName: compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         runId: options.runId,
         loopIndex: options.loopIndex,
         shellPath: shell.rootPath,
         loopRootPath: shell.loopRootPath,
-        workflowBeforePath: shell.workflowBeforePath,
-        workflowAfterPath: shell.workflowAfterPath,
+        methodBeforePath: shell.methodBeforePath,
+        methodAfterPath: shell.methodAfterPath,
         promptLogPath: shell.promptLogPath,
         eventLogPath: shell.eventLogPath,
         statusLogPath: shell.statusLogPath,
@@ -188,14 +189,14 @@ export async function runWorkflowImprovementLoop(options) {
         summary: session.summary,
     }), {
         targetName: compiledName,
-        workflowId: options.workflowId,
+        methodId: options.methodId,
         maxLoops: options.maxLoops,
         maxAttempts: options.maxAttempts,
     });
     if (session.status === "updated") {
-        updateCompiledWorkflowOrigin({
+        updateCompiledMethodOrigin({
             compiledPath: options.compiledPath,
-            selectedWorkflowId: options.workflowId,
+            selectedMethodId: options.methodId,
             localDraft: true,
         });
     }

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

@@ -1,4 +1,4 @@
-import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "../compiler/workflow-primitives.js";
+import { COMPILED_ZONE_KINDS, type CompiledZoneKind } from "../compiler/method-primitives.js";
 export declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";

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

@@ -1,8 +1,8 @@
 import { join } from "node:path";
 import { z } from "zod";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { COMPILED_ZONE_KINDS } from "../compiler/workflow-primitives.js";
-import { WorkflowCompiledSchemaSchema } from "../compiler/lib/schema.js";
+import { COMPILED_ZONE_KINDS } from "../compiler/method-primitives.js";
+import { MethodCompiledSchemaSchema } from "../compiler/lib/schema.js";
 import { PACKAGE_ROOT } from "./lib/package-root.js";
 export const BUILTIN_COMPILED_STAGE_IDS = {
     SUMMARIZE: "summarize",
@@ -20,44 +20,44 @@ export const BUILTIN_COMPILED_ZONE_IDS = {
 };
 const BUILTIN_ZONE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_ZONE_IDS));
 const BUILTIN_STAGE_ID_SET = new Set(Object.values(BUILTIN_COMPILED_STAGE_IDS));
-const BuiltinWorkflowStageSchema = z.object({
+const BuiltinMethodStageSchema = z.object({
     id: z.string(),
     contract_type: z.string(),
     reads: z.array(z.string()).min(1),
     writes: z.array(z.string()).min(1),
 });
-const BuiltinWorkflowPackageSchema = z.object({
-    stages: z.array(BuiltinWorkflowStageSchema).min(1),
+const BuiltinMethodPackageSchema = z.object({
+    stages: z.array(BuiltinMethodStageSchema).min(1),
 });
 let builtinCompiledContractCache = null;
-function builtinWorkflowRootPath() {
-    return join(PACKAGE_ROOT, "builtin-workflows", "interf");
+function builtinMethodRootPath() {
+    return join(PACKAGE_ROOT, "builtin-methods", "interf-default");
 }
-function builtinWorkflowPath(relativePath) {
-    return join(builtinWorkflowRootPath(), relativePath);
+function builtinMethodPath(relativePath) {
+    return join(builtinMethodRootPath(), relativePath);
 }
 function assertBuiltinZoneId(value) {
     if (!BUILTIN_ZONE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow schema declares unsupported zone id "${value}".`);
+        throw new Error(`Built-in Interf Method schema declares unsupported zone id "${value}".`);
     }
     return value;
 }
 function assertBuiltinStageId(value) {
     if (!BUILTIN_STAGE_ID_SET.has(value)) {
-        throw new Error(`Built-in Interf workflow package declares unsupported stage id "${value}".`);
+        throw new Error(`Built-in Interf Method package declares unsupported stage id "${value}".`);
     }
     return value;
 }
 function loadBuiltinCompiledContract() {
     if (builtinCompiledContractCache)
         return builtinCompiledContractCache;
-    const schema = readJsonFileWithSchema(builtinWorkflowPath("workflow.schema.json"), "built-in Interf workflow schema", WorkflowCompiledSchemaSchema);
+    const schema = readJsonFileWithSchema(builtinMethodPath("method.schema.json"), "built-in Interf Method schema", MethodCompiledSchemaSchema);
     if (!schema) {
-        throw new Error(`Missing or invalid built-in workflow schema at ${builtinWorkflowPath("workflow.schema.json")}.`);
+        throw new Error(`Missing or invalid built-in Method schema at ${builtinMethodPath("method.schema.json")}.`);
     }
-    const workflow = readJsonFileWithSchema(builtinWorkflowPath("workflow.json"), "built-in Interf workflow package", BuiltinWorkflowPackageSchema);
-    if (!workflow) {
-        throw new Error(`Missing or invalid built-in workflow package at ${builtinWorkflowPath("workflow.json")}.`);
+    const method = readJsonFileWithSchema(builtinMethodPath("method.json"), "built-in Interf Method package", BuiltinMethodPackageSchema);
+    if (!method) {
+        throw new Error(`Missing or invalid built-in Method package at ${builtinMethodPath("method.json")}.`);
     }
     const zones = schema.zones.map((zone) => ({
         id: assertBuiltinZoneId(zone.id),
@@ -67,7 +67,7 @@ function loadBuiltinCompiledContract() {
         required: zone.required,
         description: zone.description,
     }));
-    const stages = workflow.stages.map((stage) => ({
+    const stages = method.stages.map((stage) => ({
         id: assertBuiltinStageId(stage.id),
         contract_type: stage.contract_type,
         reads: stage.reads.map(assertBuiltinZoneId),