@interf/compiler 0.9.1 → 0.9.4

package/dist/packages/testing/readiness-check-run.js

@@ -0,0 +1,258 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { buildTestSpecFromCompiledPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveSourcePreparationPath, } from "../project-model/source-config.js";
+import { preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, portableContextPath, } from "../project-model/project-paths.js";
+import { testRootForCompiled } from "../compiler/compiled-paths.js";
+import { readJsonFileWithSchema } from "../shared/parse.js";
+import { resolveMethodId } from "../methods/method-resolution.js";
+import { createCompiledTestTarget, createRawTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
+import { ReadinessCheckRunSchema, } from "./lib/schema.js";
+export function readinessPassRate(outcome) {
+    return outcome.result.totalCases > 0
+        ? Math.round((outcome.result.passedCases / outcome.result.totalCases) * 100)
+        : 0;
+}
+function visibleRunPath(outcome) {
+    return outcome.displayRunPath ?? outcome.runPath;
+}
+function summarizeSavedTestOutcome(label, outcome) {
+    return {
+        label,
+        run_path: visibleRunPath(outcome),
+        ok: outcome.result.ok,
+        passed_cases: outcome.result.passedCases,
+        total_cases: outcome.result.totalCases,
+        passed_checks: outcome.result.passedChecks,
+        total_checks: outcome.result.totalChecks,
+        target: outcome.target,
+    };
+}
+function writePreparationTargetRun(options) {
+    const dirPath = preparationTestRunsRoot(options.projectPath, options.preparationName, options.target);
+    mkdirSync(dirPath, { recursive: true });
+    const runPath = preparationTestRunPath(options.projectPath, options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
+    return runPath;
+}
+function renderLatestSummaryMarkdown(payload) {
+    const lines = [
+        "# Latest Readiness Results",
+        "",
+        "| Target | Readiness checks |",
+        "| --- | --- |",
+    ];
+    if (payload.raw) {
+        lines.push(`| Source files | \`${payload.raw.passed_cases}/${payload.raw.total_cases}\` |`);
+    }
+    if (payload.compiled) {
+        lines.push(`| Portable Context | \`${payload.compiled.passed_cases}/${payload.compiled.total_cases}\` |`);
+    }
+    lines.push("");
+    if (payload.summary.raw_pass_rate != null && payload.summary.compiled_pass_rate != null) {
+        const direction = (payload.summary.pass_rate_delta ?? 0) >= 0 ? "improved" : "decreased";
+        lines.push(`Readiness-check pass rate ${direction} from ${payload.summary.raw_pass_rate}% to ${payload.summary.compiled_pass_rate}%.`, "");
+    }
+    if (payload.raw) {
+        lines.push(`- Latest source-files run: ${payload.raw.run_path}`);
+    }
+    if (payload.compiled) {
+        lines.push(`- Latest portable-context run: ${payload.compiled.run_path}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function readSavedReadinessCheckRun(projectPath, preparationName) {
+    const latestPath = preparationLatestReadinessRunPath(projectPath, preparationName);
+    if (!existsSync(latestPath))
+        return null;
+    return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
+}
+export function parseReadinessCheckRun(value) {
+    const parsed = ReadinessCheckRunSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+export function readReadinessCheckRunAtPath(filePath, label = "readiness-check run") {
+    return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
+}
+export function readCurrentSavedReadinessCheckRun(options) {
+    const latestComparison = readSavedReadinessCheckRun(options.projectPath, options.preparationName);
+    if (!latestComparison) {
+        return { comparison: null, stale: false };
+    }
+    const currentFingerprint = fingerprintReadinessChecks(options.checks);
+    if (!latestComparison.checks_fingerprint || latestComparison.checks_fingerprint !== currentFingerprint) {
+        return { comparison: null, stale: true };
+    }
+    return { comparison: latestComparison, stale: false };
+}
+export function saveReadinessCheckRun(options) {
+    const generatedAt = new Date().toISOString();
+    const rawSummary = options.rawOutcome
+        ? summarizeSavedTestOutcome("Source files", options.rawOutcome)
+        : null;
+    const compiledSummary = options.compiledOutcome
+        ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
+        : null;
+    const effectiveMode = rawSummary && compiledSummary
+        ? "both"
+        : rawSummary
+            ? "raw"
+            : "compiled";
+    const rawPassRate = rawSummary
+        ? Math.round((rawSummary.passed_cases / rawSummary.total_cases) * 100)
+        : null;
+    const compiledPassRate = compiledSummary
+        ? Math.round((compiledSummary.passed_cases / compiledSummary.total_cases) * 100)
+        : null;
+    const payload = {
+        kind: "interf-readiness-check-run",
+        version: 1,
+        generated_at: generatedAt,
+        mode: effectiveMode,
+        source_path: options.sourcePath,
+        checks_fingerprint: options.checksFingerprint,
+        preparation: {
+            name: options.preparationName,
+            portable_context_path: options.portableContextPath,
+        },
+        raw: rawSummary,
+        compiled: compiledSummary,
+        summary: {
+            raw_pass_rate: rawPassRate,
+            compiled_pass_rate: compiledPassRate,
+            pass_rate_delta: rawPassRate !== null && compiledPassRate !== null ? compiledPassRate - rawPassRate : null,
+        },
+    };
+    const latestStatePath = preparationLatestReadinessRunPath(options.sourcePath, options.preparationName);
+    mkdirSync(dirname(latestStatePath), { recursive: true });
+    writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
+    writeFileSync(preparationLatestReadinessSummaryPath(options.sourcePath, options.preparationName), renderLatestSummaryMarkdown(payload));
+    if (options.portableContextPath) {
+        mkdirSync(testRootForCompiled(options.portableContextPath), { recursive: true });
+        writeFileSync(join(testRootForCompiled(options.portableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
+    }
+    return latestStatePath;
+}
+export async function runSavedSourceFilesCheck(options) {
+    const spec = buildTestSpecFromSourceFolderConfig({
+        sourcePath: options.sourcePath,
+        targetName: options.preparationConfig.name,
+        targetType: "raw",
+    });
+    if (!spec)
+        return null;
+    const sourceFolderPath = resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
+    const target = createRawTestTarget(sourceFolderPath);
+    const artifactRoot = preparationLatestReadinessRunPath(options.sourcePath, options.preparationConfig.name);
+    const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
+        executor: options.executor,
+        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: dirname(artifactRoot),
+    });
+    const result = run.results[0];
+    if (!result)
+        return null;
+    const preparationRunPath = writePreparationTargetRun({
+        projectPath: options.sourcePath,
+        preparationName: options.preparationConfig.name,
+        target: "file-as-is",
+        generatedAt: run.generated_at,
+        runId: normalizePreparationTestRunId(spec.id),
+        runSuffix: options.runSuffix,
+        payload: run,
+    });
+    return {
+        runPath: preparationRunPath,
+        target,
+        result,
+    };
+}
+export async function runSavedPortableContextCheck(options) {
+    const portableContextPath = options.portableContextPath
+        ?? portableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
+    const spec = buildTestSpecFromCompiledPreparationConfig({
+        compiledPath: portableContextPath,
+        targetType: "compiled",
+    });
+    if (!spec)
+        return null;
+    const target = createCompiledTestTarget(portableContextPath, options.preparationConfig.name, resolveMethodId(options.preparationConfig));
+    if (!target.eligible)
+        return null;
+    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
+        executor: options.executor,
+        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
+        artifactRootPath: portableContextPath,
+    });
+    const result = run.results[0];
+    if (!result)
+        return null;
+    const compiledRunPath = saveTargetTestRun(portableContextPath, run);
+    const preparationRunPath = writePreparationTargetRun({
+        projectPath: options.sourcePath,
+        preparationName: options.preparationConfig.name,
+        target: "compiled",
+        generatedAt: run.generated_at,
+        runId: normalizePreparationTestRunId(spec.id),
+        runSuffix: options.runSuffix,
+        payload: run,
+    });
+    return {
+        runPath: compiledRunPath,
+        displayRunPath: preparationRunPath,
+        target,
+        result,
+    };
+}
+export async function runReadinessChecksForExecutor(options) {
+    const rawPromise = options.mode === "raw" || options.mode === "both"
+        ? runSavedSourceFilesCheck({
+            sourcePath: options.sourcePath,
+            preparationConfig: options.preparationConfig,
+            executor: options.executor,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.runSuffix,
+        })
+        : Promise.resolve(null);
+    const compiledPromise = options.mode === "compiled" || options.mode === "both"
+        ? runSavedPortableContextCheck({
+            sourcePath: options.sourcePath,
+            preparationConfig: options.preparationConfig,
+            executor: options.executor,
+            portableContextPath: options.portableContextPath,
+            preserveSandboxes: options.preserveSandboxes,
+            runSuffix: options.runSuffix,
+        })
+        : Promise.resolve(null);
+    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
+    const modeSatisfied = (options.mode !== "raw" || Boolean(rawOutcome)) &&
+        (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
+        (options.mode !== "both" || (Boolean(rawOutcome) && Boolean(compiledOutcome)));
+    const shouldSave = options.saveLatest !== false;
+    const comparisonRunPath = shouldSave && modeSatisfied
+        ? saveReadinessCheckRun({
+            sourcePath: options.sourcePath,
+            portableContextPath: options.portableContextPath,
+            preparationName: options.preparationConfig.name,
+            checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
+            mode: options.mode,
+            rawOutcome,
+            compiledOutcome,
+        })
+        : null;
+    const comparison = shouldSave && modeSatisfied
+        ? readSavedReadinessCheckRun(options.sourcePath, options.preparationConfig.name)
+        : null;
+    return {
+        sourcePath: options.sourcePath,
+        preparationConfig: options.preparationConfig,
+        portableContextPath: options.portableContextPath,
+        mode: options.mode,
+        rawOutcome,
+        compiledOutcome,
+        comparisonRunPath,
+        comparison,
+    };
+}
+function portableContextPathForPreparation(sourcePath, preparationName) {
+    return portableContextPath(sourcePath, preparationName);
+}

package/dist/packages/testing/test-execution.d.ts

@@ -1,13 +1,13 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
 import type { TestTargetRun, TestTargetCandidate, LoadedTestSpec } from "./test-types.js";
 import { type TestSandboxRetentionMode } from "./test-sandbox.js";
 export declare function runTargetTests(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[]): TestTargetRun;
-export declare function runTargetTestsWithJudge(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], executor: WorkflowExecutor, options?: {
+export declare function runTargetTestsWithJudge(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], executor: MethodExecutor, options?: {
     preserveSandboxes?: TestSandboxRetentionMode;
     artifactRootPath?: string;
 }): Promise<TestTargetRun>;
 export declare function runTargetTestsAuto(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], options?: {
-    executor?: WorkflowExecutor | null;
+    executor?: MethodExecutor | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     artifactRootPath?: string;
 }): Promise<TestTargetRun>;

package/dist/packages/testing/test-execution.js

@@ -197,19 +197,19 @@ async function runTargetTestsJudge(testCase, executor, candidateLabel, candidate
 function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
     const header = target.type === "compiled"
         ? [
-            "You are running an Interf test inside an isolated sandboxed compiled context.",
+            "You are running an Interf test inside an isolated sandboxed portable context.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this portable context.",
             "Answer the check question the same way you would answer a real user inside this portable context.",
-            "Prefer the workflow-declared context outputs before consulting `raw/`.",
+            "Prefer the Method-declared portable-context outputs before consulting `raw/`.",
             "This sandbox is self-contained: the copied portable context has sanitized source files under `raw/` via `.interf/interf.json` `source.path`.",
-            "The original control plane folder is intentionally absent from this sandbox. Work only from this sandboxed compiled context and its embedded raw files.",
+            "The original Interf Workspace is intentionally absent from this sandbox. Work only from this sandboxed portable context and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
             "Read `AGENTS.md` first.",
             "Use the local native `interf-query` skill available in this shell.",
-            "There is no compiled context in this sandbox.",
+            "There is no portable context in this sandbox.",
             "Answer only from `raw/` inside this shell.",
             "The original control plane folder is intentionally absent from this sandbox.",
         ];
@@ -383,7 +383,7 @@ function buildTestTargetResult(target, caseResults, options = {}) {
             type: target.type,
             name: target.name,
             path: target.path,
-            workflow: target.workflow,
+            method: target.method,
         },
         ...(options.sandboxPath ? { sandbox_path: options.sandboxPath } : {}),
         ok: passedCases === caseResults.length,

package/dist/packages/testing/test-paths.js

@@ -4,12 +4,12 @@ import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, comp
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
 export function testSpecRootPath(sourcePath) {
-    return join(sourcePath, "interf", "tests", "matrix", "specs");
+    return join(sourcePath, "interf", "tests", "specs");
 }
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
-function isDatasetTestsRootPath(artifactRootPath) {
+function isPreparationTestsRootPath(artifactRootPath) {
     return basename(artifactRootPath) === "tests" &&
         basename(dirname(artifactRootPath)) === ".interf";
 }
@@ -17,10 +17,10 @@ export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
-    if (isDatasetTestsRootPath(compiledPath)) {
+    if (isPreparationTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
 export function targetTestRunGitignorePath(compiledPath, type) {
     return join(targetTestRunsPath(compiledPath, type), ".gitignore");
@@ -29,10 +29,10 @@ export function targetTestSandboxesPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
-    if (isDatasetTestsRootPath(compiledPath)) {
+    if (isPreparationTestsRootPath(compiledPath)) {
         return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
     }
-    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/<dataset>/.interf/tests root.`);
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected portable context or interf/<preparation>/.interf/tests root.`);
 }
 export function targetTestSandboxGitignorePath(compiledPath, type) {
     return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");

package/dist/packages/testing/test-profile-presets.js

@@ -25,10 +25,10 @@ export const TestProfilePresets = {
     }),
     "release-codex-high": TestProfilePresetValueSchema.parse({
         agent: "codex",
-        model: "gpt-5.4-mini",
+        model: "gpt-5.3-codex",
         effort: "high",
         timeout_ms: 480000,
-        label: "Codex (GPT-5.4 Mini, high)",
+        label: "Codex (GPT-5.3 Codex, high)",
     }),
     "tier1-max-claude": TestProfilePresetValueSchema.parse({
         agent: "claude-code",

package/dist/packages/testing/test-sandbox.js

@@ -2,13 +2,13 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig, resolveCompiledRawPath } from "../project-model/interf.js";
+import { readInterfConfig } from "../project-model/interf.js";
 import { projectRawTestQueryShell } from "../agents/lib/shells.js";
-import { compiledCompiledPathForDataset } from "../project-model/project-paths.js";
+import { portableContextPath } from "../project-model/project-paths.js";
 import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { projectRawSnapshot } from "../compiler/raw-snapshot.js";
+import { projectRawSnapshot, resolveCompiledRawPath } from "../compiler/raw-snapshot.js";
 import { refreshCompiledArtifacts } from "../compiler/state.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
 function toPortableRelativePath(fromPath, toPath) {
     return relative(fromPath, toPath).split(sep).join("/");
 }
@@ -17,7 +17,7 @@ function sanitizeCompiledArtifacts(compiledPath) {
         testRootForCompiled(compiledPath),
         targetTestSandboxesRootForCompiled(compiledPath),
         stageExecutionShellsRoot(compiledPath),
-        workflowImprovementLoopsRoot(compiledPath),
+        methodImprovementLoopsRoot(compiledPath),
         compiledRuntimeLogsRoot(compiledPath),
         compiledQueryAcceptanceRoot(compiledPath),
     ]) {
@@ -28,13 +28,13 @@ export function createTestSandbox(target) {
     let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
     const sandboxCompiledPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        ? portableContextPath(sandboxRoot, target.name)
         : null);
     const sandboxRawPath = () => (target.type === "compiled"
-        ? join(compiledCompiledPathForDataset(sandboxRoot, target.name), "raw")
+        ? join(portableContextPath(sandboxRoot, target.name), "raw")
         : join(sandboxRoot, "raw"));
     const sandboxTargetPath = () => (target.type === "compiled"
-        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        ? portableContextPath(sandboxRoot, target.name)
         : sandboxRoot);
     try {
         if (target.type === "compiled") {
@@ -43,17 +43,16 @@ export function createTestSandbox(target) {
             sanitizeCompiledArtifacts(sandboxTargetPath());
             const sandboxConfig = readInterfConfig(sandboxTargetPath());
             if (!sandboxConfig) {
-                throw new Error(`Sandbox compiled context is missing interf.json: ${sandboxTargetPath()}`);
+                throw new Error(`Sandbox portable context is missing interf.json: ${sandboxTargetPath()}`);
             }
             if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                throw new Error(`Sandbox compiled context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled context before testing it.`);
+                throw new Error(`Sandbox portable context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the portable context before testing it.`);
             }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
-                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());

package/dist/packages/testing/test-targets.d.ts

@@ -1,5 +1,5 @@
 import type { TestTargetCandidate } from "./test-types.js";
 export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
-export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, workflowId?: string): TestTargetCandidate;
+export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
 export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
 export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/packages/testing/test-targets.js

@@ -1,20 +1,21 @@
-import { listCompiledDatasetsForSourceFolder } from "../project-model/interf-detect.js";
+import { listPortableContextsForSourceFolder } from "../project-model/interf-detect.js";
 import { computeCompiledHealth } from "../compiler/state.js";
+import { DEFAULT_METHOD_ID, resolveMethodId } from "../methods/method-resolution.js";
 function summarizeTargetSortKey(target) {
-    return `${target.name}\u0000${target.workflow}`;
+    return `${target.name}\u0000${target.method}`;
 }
 export function listCompiledTestTargets(sourcePath) {
-    return listCompiledDatasetsForSourceFolder(sourcePath)
-        .map(({ path, config }) => createCompiledTestTarget(path, config.name, config.workflow ?? "interf"))
+    return listPortableContextsForSourceFolder(sourcePath)
+        .map(({ path, config }) => createCompiledTestTarget(path, config.name, resolveMethodId(config)))
         .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
 }
-export function createCompiledTestTarget(compiledPath, compiledName, workflowId = "interf") {
+export function createCompiledTestTarget(compiledPath, compiledName, methodId = DEFAULT_METHOD_ID) {
     const health = computeCompiledHealth(compiledPath);
     return {
         type: "compiled",
         name: compiledName,
         path: compiledPath,
-        workflow: workflowId,
+        method: methodId,
         status: health.status,
         stage: health.stage,
         summary: health.summary,
@@ -26,7 +27,7 @@ export function createRawTestTarget(sourcePath) {
         type: "raw",
         name: "raw",
         path: sourcePath,
-        workflow: "raw",
+        method: "raw",
         status: "compiled",
         stage: "raw",
         summary: "Run the checks against an isolated sandbox of the raw files.",

package/dist/packages/testing/test-types.d.ts

@@ -8,7 +8,7 @@ export interface TestTargetCandidate {
     type: TestTargetType;
     name: string;
     path: string;
-    workflow: string;
+    method: string;
     status: "idle" | "running" | "compiled" | "stale" | "failed";
     stage: string;
     summary: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interf/compiler",
-  "version": "0.9.1",
+  "version": "0.9.4",
   "description": "Interf prepares data for agent work. It runs locally, processes your files, shows evidence that your data is ready, and writes portable context: a local folder with verifiable outputs agents can use.",
   "type": "module",
   "bin": {
@@ -18,13 +18,13 @@
       "types": "./dist/packages/compiler/index.d.ts",
       "import": "./dist/packages/compiler/index.js"
     },
-    "./workflow-package": {
-      "types": "./dist/packages/workflow-package/index.d.ts",
-      "import": "./dist/packages/workflow-package/index.js"
+    "./method-package": {
+      "types": "./dist/packages/method-package/index.d.ts",
+      "import": "./dist/packages/method-package/index.js"
     },
-    "./workflow-authoring": {
-      "types": "./dist/packages/workflow-authoring/index.d.ts",
-      "import": "./dist/packages/workflow-authoring/index.js"
+    "./method-authoring": {
+      "types": "./dist/packages/method-authoring/index.d.ts",
+      "import": "./dist/packages/method-authoring/index.js"
     },
     "./execution": {
       "types": "./dist/packages/execution/index.d.ts",
@@ -53,43 +53,26 @@
     "dev": "tsc --watch",
     "web:dev": "npm --prefix apps/compiler-ui run dev",
     "web:typecheck": "npm --prefix apps/compiler-ui run typecheck",
-    "web:build": "node -e \"require('fs').rmSync('apps/compiler-ui/.next',{recursive:true,force:true})\" && npm --prefix apps/compiler-ui run build",
-    "docs:sync-public-test-example": "npm run build && node scripts/docs/sync-public-test-example.mjs",
+    "web:build": "node scripts/web/build-compiler-ui.mjs",
     "docs:sync-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs",
     "docs:check-agent-skill-cli-reference": "npm run build && node scripts/docs/sync-agent-skill-cli-reference.mjs --check",
-    "test:matrix": "npm run build && node scripts/matrix/run.mjs",
     "test:smoke": "npm run build && node --test test/**/*.test.mjs",
     "test": "npm run test:smoke",
-    "test:e2e": "npm run test:acceptance-live",
-    "test:e2e:claude": "npm run test:acceptance-live -- --agent claude-code",
-    "test:e2e:codex": "npm run test:acceptance-live -- --agent codex",
-    "test:e2e:quick": "npm run test:e2e:quick:matrix",
-    "test:e2e:quick:agent": "node scripts/acceptance/run-quick-e2e.mjs",
-    "test:e2e:quick:claude": "npm run test:e2e:quick:agent -- --agent claude-code",
-    "test:e2e:quick:codex": "npm run test:e2e:quick:agent -- --agent codex",
-    "test:e2e:quick:matrix": "npm run test:e2e:quick:claude && npm run test:e2e:quick:codex",
-    "test:matrix:cbre:fast": "npm run test:matrix -- --matrix test/matrices/cbre-chart-sanity.json",
-    "test:matrix:cbre:fast:keep": "npm run test:matrix -- --matrix test/matrices/cbre-chart-sanity.json --keep-project-clones",
-    "test:matrix:cbre:max": "npm run test:matrix -- --matrix test/matrices/cbre-chart-tier1-max.json",
-    "test:matrix:cbre:max:keep": "npm run test:matrix -- --matrix test/matrices/cbre-chart-tier1-max.json --keep-project-clones",
-    "test:full": "npm test && npm run test:e2e:quick:matrix",
-    "test:release:matrix": "npm run test:matrix:cbre:max",
-    "test:release": "npm test && npm run test:acceptance-quick:workflow-authoring -- --agent claude-code && npm run test:acceptance-live -- --agent claude-code --with-test && npm run test:acceptance-quick:workflow-authoring -- --agent codex && npm run test:acceptance-live -- --agent codex --with-test",
+    "test:full": "npm test && npm run web:build",
+    "test:e2e": "npm run test:acceptance",
+    "test:e2e:claude": "npm run test:acceptance-live -- --agent claude-code --with-test",
+    "test:e2e:codex": "npm run test:acceptance-live -- --agent codex --with-test",
+    "test:acceptance": "npm run build && node scripts/acceptance/release.mjs",
+    "test:release": "npm run web:typecheck && npm test && node scripts/acceptance/release.mjs && npm run web:build",
     "test:acceptance-live": "npm run build && node scripts/acceptance/live.mjs",
-    "test:e2e:quick:refresh-cache": "npm run test:e2e:quick:refresh-cache:claude && npm run test:e2e:quick:refresh-cache:codex",
-    "test:e2e:quick:refresh-cache:claude": "node scripts/acceptance/refresh-quick-cache.mjs --agent claude-code",
-    "test:e2e:quick:refresh-cache:codex": "node scripts/acceptance/refresh-quick-cache.mjs --agent codex",
     "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance/targeted.mjs create-compiled",
     "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance/targeted.mjs compiled-query",
-    "test:acceptance-quick:workflow-authoring": "npm run build && node scripts/acceptance/targeted.mjs workflow-authoring",
     "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance/targeted.mjs self-improving-compile",
     "prepublishOnly": "node scripts/release/prepublish-gate.mjs"
   },
   "files": [
     "dist",
-    "apps/compiler-ui/.next/server/app/index.html",
-    "apps/compiler-ui/.next/static",
-    "builtin-workflows",
+    "builtin-methods",
     "agent-skills",
     "TRADEMARKS.md"
   ],
@@ -107,7 +90,7 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/interf-labs/interf"
+    "url": "git+https://github.com/interf-labs/interf.git"
   },
   "bugs": {
     "url": "https://github.com/interf-labs/interf/issues"