@interf/compiler 0.7.3 → 0.9.3

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

@@ -4,7 +4,7 @@ import chalk from "chalk";
 import { countFilesRecursive } from "../shared/filesystem.js";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
 import { RuntimeRunSchema, } from "./lib/schema.js";
-import { getWorkflowStageDefinition, getWorkflowStagePosition, getWorkflowStages, } from "../workflow-package/workflow-definitions.js";
+import { getMethodStageDefinition, getMethodStagePosition, getMethodStages, } from "../method-package/method-definitions.js";
 import { archivedStageContractPath, eventLogPath, logsDirPath, promptLogPath, runHistoryPath, runPath, stageContractPath, statusLogPath, } from "./runtime-paths.js";
 import { warnInterf } from "../shared/logger.js";
 export function loadRuntimeRun(dirPath) {
@@ -49,6 +49,7 @@ export async function runExecutorStage(options) {
         eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
         statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
+        onStatus: options.onStatus,
     });
     finalizeRuntimeRun(options.compiledPath, code);
     return code;
@@ -63,6 +64,7 @@ export async function runExecutorSummarizeStage(options) {
         eventLogPath: eventLogPath(options.compiledPath, startedRun.run.run_id),
         statusLogPath: statusLogPath(options.compiledPath, startedRun.run.run_id),
         completionCheck: options.completionCheck,
+        onStatus: options.onStatus,
     });
     const timer = setInterval(() => {
         const currentSummaryCount = countFilesRecursive(join(options.compiledPath, "summaries"));
@@ -79,6 +81,7 @@ export async function runExecutorSummarizeStage(options) {
             summary: `${options.stageLabel} ${completed}/${options.targetCount} source files into summaries.`,
         });
         console.log(chalk.dim(`  STATUS: wrote ${completed}/${options.targetCount} summaries`));
+        options.onStatus?.(`STATUS: wrote ${completed}/${options.targetCount} summaries`);
     }, 10000);
     try {
         const code = await progressPromise;
@@ -144,9 +147,9 @@ export function markRuntimeRunSucceededAfterValidation(dirPath, summary) {
 function startRuntimeRun(options) {
     const runId = createRunId();
     const generatedAt = new Date().toISOString();
-    const workflowStages = getWorkflowStages(options.workflow, options.workflowSourcePath);
-    const stagePosition = getWorkflowStagePosition(options.workflow, options.stage, options.workflowSourcePath);
-    const stageDefinition = getWorkflowStageDefinition(options.workflow, options.stage, options.workflowSourcePath);
+    const methodStages = getMethodStages(options.method, options.methodSourcePath);
+    const stagePosition = getMethodStagePosition(options.method, options.stage, options.methodSourcePath);
+    const stageDefinition = getMethodStageDefinition(options.method, options.stage, options.methodSourcePath);
     const contract = {
         kind: "interf-stage-contract",
         version: 1,
@@ -154,11 +157,11 @@ function startRuntimeRun(options) {
         run_id: runId,
         target_type: "compiled",
         target_name: options.compiledName,
-        workflow: {
-            id: options.workflow,
+        method: {
+            id: options.method,
             stage_index: stagePosition?.stageIndex ?? null,
-            stage_total: stagePosition?.stageTotal ?? workflowStages.length,
-            stages: stagePosition?.stages ?? workflowStages,
+            stage_total: stagePosition?.stageTotal ?? methodStages.length,
+            stages: stagePosition?.stages ?? methodStages,
         },
         stage: options.stage,
         stage_label: stageDefinition?.label ?? options.stageLabel,
@@ -178,7 +181,7 @@ function startRuntimeRun(options) {
         run_id: runId,
         target_type: "compiled",
         target_name: options.compiledName,
-        workflow: options.workflow,
+        method: options.method,
         stage: options.stage,
         stage_label: stageDefinition?.label ?? options.stageLabel,
         contract_type: options.contractType,

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

@@ -1,14 +1,15 @@
-import { type WorkflowExecutor } from "../agents/lib/executors.js";
-import { type WorkflowId, type RuntimeContractType, type RuntimeRun, type RuntimeStage, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
+import { type MethodExecutor } from "../agents/lib/executors.js";
+import { type RuntimeRun, type RuntimeStageAcceptance, type RuntimeStageContract, type RuntimeStageInstructions } from "./lib/schema.js";
+import type { MethodId, RuntimeContractType, RuntimeStage } from "../contracts/lib/schema.js";
 export type RuntimeRunStatus = "running" | "succeeded" | "failed";
-export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "workflow" | "stage" | "stage_label" | "contract_type" | "executor">;
+export type RuntimeStageContractDraft = Omit<RuntimeStageContract, "kind" | "version" | "generated_at" | "run_id" | "target_type" | "target_name" | "method" | "stage" | "stage_label" | "contract_type" | "executor">;
 export interface RuntimeStageExecutionOptions {
-    executor: WorkflowExecutor;
+    executor: MethodExecutor;
     compiledPath: string;
     executionPath?: string;
     compiledName: string;
-    workflow: WorkflowId;
-    workflowSourcePath?: string;
+    method: MethodId;
+    methodSourcePath?: string;
     stage: RuntimeStage;
     stageLabel: string;
     contractType: RuntimeContractType;
@@ -16,6 +17,7 @@ export interface RuntimeStageExecutionOptions {
     contract: RuntimeStageContractDraft;
     buildPrompt: (contractPath: string) => string;
     completionCheck?: (() => boolean) | null;
+    onStatus?: (line: string) => void;
 }
 export interface RuntimeSummarizeExecutionOptions extends RuntimeStageExecutionOptions {
     startingSummaryCount: number;
@@ -34,7 +36,7 @@ export interface RuntimeStageContractOptions {
     extraReadArtifacts?: string[];
     stageReadArtifacts: string[];
     stageWriteArtifacts: string[];
-    workflowNotes?: string[];
+    methodNotes?: string[];
     localSkillDocs?: string[];
     instructions: RuntimeStageInstructions;
     acceptance?: RuntimeStageAcceptance;

package/dist/packages/compiler/state-health.js

@@ -1,22 +1,13 @@
-import { basename, join } from "node:path";
-import { existsSync } from "node:fs";
+import { basename } from "node:path";
 import { readInterfConfig, resolveSourceFolderPath, } from "../project-model/interf-detect.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
-import { validateCompiled, validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
+import { validateCompiled, validateCompiledStage, validateCompiledMethod, } from "./validate.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "../workflow-package/workflow-definitions.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = join(compiledPath, zonePath);
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
+import { countCompiledZoneArtifacts } from "./artifact-counts.js";
 export function computeCompiledHealth(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
@@ -26,38 +17,38 @@ export function computeCompiledHealth(dirPath) {
     const state = loadState(dirPath);
     const validation = validateCompiled(dirPath);
     const activeRun = loadRuntimeRun(dirPath);
-    const workflowId = config
-        ? resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`)
+    const methodId = config
+        ? resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`)
         : null;
-    let workflow = null;
-    if (workflowId) {
+    let method = null;
+    if (methodId) {
         try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+            method = getActiveCompiledMethod(dirPath);
         }
         catch {
-            workflow = null;
+            method = null;
         }
     }
-    const stageResults = workflow?.stages.map((stage) => ({
+    const stageResults = method?.stages.map((stage) => ({
         stage,
         validation: validateCompiledStage(dirPath, stage.id),
     })) ?? [];
     const completedStages = stageResults.filter((entry) => entry.validation.ok).length;
     const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
-    const workflowValidation = validateCompiledWorkflow(dirPath);
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const methodValidation = validateCompiledMethod(dirPath);
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     const zoneMetrics = Object.fromEntries((schema?.zones ?? []).map((zone) => [
         `zone_${zone.id}`,
-        countZoneArtifacts(dirPath, zone.path, zone.kind),
+        countCompiledZoneArtifacts(dirPath, zone.path, zone.kind),
     ]));
     let status = "idle";
     let stage = "idle";
     let summary = "Idle — no source files have been compiled yet.";
-    const errors = workflowValidation.errors.length;
-    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.workflow_valid || !validation.schema_valid) {
+    const errors = methodValidation.errors.length;
+    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.method_valid || !validation.schema_valid) {
         status = "failed";
         stage = "failed";
-        summary = workflowValidation.summary;
+        summary = methodValidation.summary;
     }
     else if (activeRun?.status === "running") {
         status = "running";
@@ -74,22 +65,22 @@ export function computeCompiledHealth(dirPath) {
         stage = activeRun.stage;
         summary = activeRun.error ?? activeRun.summary;
     }
-    else if (workflowValidation.ok) {
+    else if (methodValidation.ok) {
         status = "compiled";
         stage = "compiled";
-        summary = `Compiled — ${completedStages}/${workflow?.stages.length ?? 0} workflow stages satisfied.`;
+        summary = `Compiled — ${completedStages}/${method?.stages.length ?? 0} method stages satisfied.`;
     }
     else {
         status = "stale";
         stage = firstFailed?.stage.id ?? "compiled";
-        summary = firstFailed?.validation.summary ?? workflowValidation.summary;
+        summary = firstFailed?.validation.summary ?? methodValidation.summary;
     }
     const checks = {
         ...validation,
-        ...(workflow
-            ? Object.fromEntries(workflow.stages.map((workflowStage) => [
-                `stage_${workflowStage.id}_ok`,
-                stageResults.find((entry) => entry.stage.id === workflowStage.id)?.validation.ok ?? false,
+        ...(method
+            ? Object.fromEntries(method.stages.map((methodStage) => [
+                `stage_${methodStage.id}_ok`,
+                stageResults.find((entry) => entry.stage.id === methodStage.id)?.validation.ok ?? false,
             ]))
             : {}),
     };
@@ -103,7 +94,7 @@ export function computeCompiledHealth(dirPath) {
         summary,
         metrics: {
             source_total: sourceTotal,
-            stage_total: workflow?.stages.length ?? 0,
+            stage_total: method?.stages.length ?? 0,
             completed_stages: completedStages,
             warnings: state?.warning_count ?? 0,
             errors: (state?.error_count ?? 0) + errors,

package/dist/packages/compiler/state-view.js

@@ -4,9 +4,9 @@ import { discoverSourceFiles } from "./discovery.js";
 import { readInterfConfig, resolveSourceFolderPath } from "../project-model/interf-detect.js";
 import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { rawSnapshotPath } from "./state-paths.js";
-import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { compiledRuntimeRoot, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "../workflow-package/workflow-definitions.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
 export function ensureCompiledViewSpec(dirPath) {
     const existing = loadCompiledViewSpec(dirPath);
     const now = new Date().toISOString();
@@ -70,9 +70,9 @@ export function normalizeCompiledViewSpec(existing, defaults) {
 }
 function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     const config = readInterfConfig(dirPath);
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`);
-    const workflow = getActiveCompiledWorkflow(dirPath, workflowId);
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`);
+    const method = getActiveCompiledMethod(dirPath);
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     const outputDocumentPaths = (schema?.zones ?? [])
         .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
         .map((zone) => zone.path);
@@ -97,7 +97,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
             ...(outputDocumentPaths.length > 0
                 ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
                 : []),
-            { id: "workflow", type: "documents", title: "Workflow Docs", paths: ["workflow/README.md", ...workflow.stages.map((stage) => `workflow/compile/stages/${stage.skillDir}`)] },
+            { id: "method", type: "documents", title: "Method Docs", paths: ["method/README.md", ...method.stages.map((stage) => `method/compile/stages/${stage.skillDir}`)] },
         ],
     };
 }

package/dist/packages/compiler/validate-compiled.d.ts

@@ -2,8 +2,8 @@ export interface CompiledValidationSummary {
     config_present: boolean;
     config_valid: boolean;
     config_type_match: boolean;
-    workflow_present: boolean;
-    workflow_valid: boolean;
+    method_present: boolean;
+    method_valid: boolean;
     schema_present: boolean;
     schema_valid: boolean;
 }
@@ -16,12 +16,12 @@ export interface CompiledStageValidation {
     checks: Record<string, boolean>;
     errors: string[];
 }
-export interface CompiledWorkflowValidation extends CompiledStageValidation {
+export interface CompiledMethodValidation extends CompiledStageValidation {
     stage_results: Record<string, boolean>;
 }
 export declare function validateCompiled(dirPath: string): CompiledValidationSummary;
 export declare function validateCompiledStage(dirPath: string, stageId: string): CompiledStageValidation;
-export declare function validateCompiledWorkflow(dirPath: string): CompiledWorkflowValidation;
+export declare function validateCompiledMethod(dirPath: string): CompiledMethodValidation;
 export declare function validateCompiledSummarize(dirPath: string): CompiledStageValidation;
 export declare function validateCompiledStructure(dirPath: string): CompiledStageValidation;
-export declare function validateCompiledCompile(dirPath: string): CompiledWorkflowValidation;
+export declare function validateCompiledCompile(dirPath: string): CompiledMethodValidation;

package/dist/packages/compiler/validate-compiled.js

@@ -1,51 +1,45 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { discoverSourceFiles } from "./discovery.js";
-import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
+import { METHOD_SCHEMA_FILE, findCompiledSchemaZone, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
 import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
-import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { compiledInterfConfigPath, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
 import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "../workflow-package/workflow-definitions.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
-function workflowSchemaPresent(dirPath) {
-    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
+import { countCompiledZoneArtifacts } from "./artifact-counts.js";
+function methodSchemaPresent(dirPath) {
+    return methodSchemaExists(methodPackagePathForCompiled(dirPath));
 }
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
+function methodJsonPresent(dirPath) {
+    return existsSync(methodPackagePathForCompiled(dirPath) + "/method.json");
 }
-function readWorkflowContext(dirPath) {
+function readMethodContext(dirPath) {
     const config = readCompiledConfig(dirPath);
-    const workflowId = config.valid
-        ? resolveRequiredCompiledWorkflowFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
+    const methodId = config.valid
+        ? resolveRequiredCompiledMethodFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
         : null;
-    let workflow = null;
-    if (workflowId) {
+    let method = null;
+    if (methodId) {
         try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+            method = getActiveCompiledMethod(dirPath);
         }
         catch {
-            workflow = null;
+            method = null;
         }
     }
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
     const state = loadState(dirPath);
     const sourceTotal = config.valid
         ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
         : 0;
     return {
         config,
-        workflow,
+        method,
         schema,
         state,
         sourceTotal,
-        workflowId,
+        methodId,
     };
 }
 function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
@@ -58,7 +52,7 @@ function zoneWriteCount(compiledPath, schema, stage) {
         const zone = findCompiledSchemaZone(schema, zoneId);
         if (!zone)
             continue;
-        const count = countZoneArtifacts(compiledPath, zone.path, zone.kind);
+        const count = countCompiledZoneArtifacts(compiledPath, zone.path, zone.kind);
         zoneCounts[zoneId] = count;
         total += count;
     }
@@ -80,26 +74,26 @@ function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
     return merged;
 }
 export function validateCompiled(dirPath) {
-    const context = readWorkflowContext(dirPath);
+    const context = readMethodContext(dirPath);
     return {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
+        method_present: methodJsonPresent(dirPath),
+        method_valid: context.method !== null,
+        schema_present: methodSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
 }
 export function validateCompiledStage(dirPath, stageId) {
-    const context = readWorkflowContext(dirPath);
+    const context = readMethodContext(dirPath);
     const checks = {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
+        method_present: methodJsonPresent(dirPath),
+        method_valid: context.method !== null,
+        schema_present: methodSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     const errors = [];
@@ -108,34 +102,34 @@ export function validateCompiledStage(dirPath, stageId) {
     else if (!checks.config_valid)
         errors.push(`Could not parse ${compiledInterfConfigPath(dirPath)}.`);
     else if (!checks.config_type_match)
-        errors.push("Config is not a compiled context.");
-    if (!checks.workflow_present)
-        errors.push("Missing .interf/workflow/workflow.json.");
-    else if (!checks.workflow_valid)
-        errors.push("Could not load the active workflow package.");
+        errors.push("Config is not a portable context.");
+    if (!checks.method_present)
+        errors.push("Missing .interf/method/method.json.");
+    else if (!checks.method_valid)
+        errors.push("Could not load the active Method package.");
     if (!checks.schema_present)
-        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
+        errors.push(`Missing .interf/method/${METHOD_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
-        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
-    const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
-    checks.stage_present = workflowStage !== null;
+        errors.push(`Could not parse .interf/method/${METHOD_SCHEMA_FILE}.`);
+    const methodStage = context.method?.stages.find((stage) => stage.id === stageId) ?? null;
+    checks.stage_present = methodStage !== null;
     if (!checks.stage_present) {
-        errors.push(`Workflow does not declare stage "${stageId}".`);
+        errors.push(`Method does not declare stage "${stageId}".`);
     }
     const stageRecord = stageRecordFromState(context.state, stageId);
     checks.stage_record_present = stageRecord !== null;
     checks.stage_finished = Boolean(stageRecord?.finished_at);
     checks.stage_succeeded = stageRecord?.status === "succeeded";
-    const writeCounts = workflowStage && context.schema
-        ? zoneWriteCount(dirPath, context.schema, workflowStage)
+    const writeCounts = methodStage && context.schema
+        ? zoneWriteCount(dirPath, context.schema, methodStage)
         : { total: 0, zoneCounts: {} };
     const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
     const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
     let acceptanceErrors = [];
-    if (workflowStage && context.schema) {
+    if (methodStage && context.schema) {
         const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
             stageId,
-            acceptance: workflowStage.acceptance,
+            acceptance: methodStage.acceptance,
             counts: acceptanceCounts,
         });
         checks.acceptance_ok = acceptanceValidation.ok;
@@ -167,30 +161,30 @@ export function validateCompiledStage(dirPath, stageId) {
         counts: {
             ...acceptanceCounts,
             write_artifacts: writeCounts.total,
-            declared_write_zones: workflowStage?.writes.length ?? 0,
+            declared_write_zones: methodStage?.writes.length ?? 0,
         },
         checks,
         errors,
     };
 }
-export function validateCompiledWorkflow(dirPath) {
-    const context = readWorkflowContext(dirPath);
+export function validateCompiledMethod(dirPath) {
+    const context = readMethodContext(dirPath);
     const checks = {
         config_present: context.config.present,
         config_valid: context.config.valid,
         config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
+        method_present: methodJsonPresent(dirPath),
+        method_valid: context.method !== null,
+        schema_present: methodSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
-    if (!context.workflow) {
-        const errors = ["Could not load the active workflow package."];
+    if (!context.method) {
+        const errors = ["Could not load the active Method package."];
         return {
             ok: false,
             required: true,
-            stage: "workflow",
-            summary: `Compiled workflow failed — ${errors[0]}`,
+            stage: "method",
+            summary: `Compiled Method failed — ${errors[0]}`,
             counts: { source_total: context.sourceTotal, stage_total: 0, completed_stages: 0 },
             checks,
             errors,
@@ -201,7 +195,7 @@ export function validateCompiledWorkflow(dirPath) {
     const errors = [];
     let completedStages = 0;
     let failedStage = "compiled";
-    for (const stage of context.workflow.stages) {
+    for (const stage of context.method.stages) {
         const validation = validateCompiledStage(dirPath, stage.id);
         stageResults[stage.id] = validation.ok;
         if (validation.ok) {
@@ -218,11 +212,11 @@ export function validateCompiledWorkflow(dirPath) {
         required: context.sourceTotal > 0,
         stage: failedStage,
         summary: ok
-            ? `Compiled workflow verified — ${completedStages}/${context.workflow.stages.length} stages satisfied.`
-            : `Compiled workflow failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
+            ? `Compiled Method verified — ${completedStages}/${context.method.stages.length} stages satisfied.`
+            : `Compiled Method failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
         counts: {
             source_total: context.sourceTotal,
-            stage_total: context.workflow.stages.length,
+            stage_total: context.method.stages.length,
             completed_stages: completedStages,
         },
         checks,
@@ -237,5 +231,5 @@ export function validateCompiledStructure(dirPath) {
     return validateCompiledStage(dirPath, "structure");
 }
 export function validateCompiledCompile(dirPath) {
-    return validateCompiledWorkflow(dirPath);
+    return validateCompiledMethod(dirPath);
 }

package/dist/packages/compiler/validate.d.ts

@@ -17,5 +17,5 @@ export declare function isOutputMarkdownFile(filePath: string): boolean;
 export declare function safeReadText(filePath: string): string | null;
 export declare function extractSynthAbstract(frontmatter: Record<string, unknown>, body: string): string | null;
 export declare function countSynthAbstractWords(frontmatter: Record<string, unknown>, body: string): number;
-export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
-export type { CompiledValidationSummary, CompiledStageValidation, CompiledWorkflowValidation, } from "./validate-compiled.js";
+export { validateCompiled, validateCompiledStage, validateCompiledMethod, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
+export type { CompiledValidationSummary, CompiledStageValidation, CompiledMethodValidation, } from "./validate-compiled.js";

package/dist/packages/compiler/validate.js

@@ -1,8 +1,8 @@
 import { existsSync, readFileSync, statSync, } from "node:fs";
-import { basename, extname, join } from "node:path";
+import { basename, dirname, extname, join, resolve } from "node:path";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
 import { compiledKnowledgeRootPath } from "./compiled-schema.js";
-import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { methodPackagePathForCompiled } from "./compiled-paths.js";
 import { listFilesRecursive } from "../shared/filesystem.js";
 import { readInterfConfig } from "../project-model/interf-detect.js";
 import { parseJsonFrontmatter } from "../shared/parse.js";
@@ -75,15 +75,15 @@ export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots
             if (!target)
                 continue;
             if (target.includes("/")) {
-                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)) {
+                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath)) {
                     brokenLinks += 1;
                 }
                 continue;
             }
             if (!noteIndex.has(target.toLowerCase()) &&
                 !noteIndex.has(noteName(target).toLowerCase()) &&
-                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) &&
-                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes)) {
+                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes, filePath)) {
                 brokenLinks += 1;
             }
         }
@@ -172,13 +172,16 @@ function countWords(text) {
 function noteName(filePath) {
     return basename(filePath, extname(filePath));
 }
-function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
-    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)
+function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
+    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath)
         .some((candidate) => existsSync(candidate));
 }
-function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
     const candidates = new Set();
     addPathCandidate(candidates, join(compiledRoot, target));
+    if (sourceFilePath && (target.startsWith("./") || target.startsWith("../"))) {
+        addPathCandidateIfInside(candidates, compiledRoot, resolve(dirname(sourceFilePath), target));
+    }
     const [firstSegment] = target.split("/");
     if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
         addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
@@ -194,13 +197,18 @@ function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativ
 }
 function addPathCandidate(candidates, absolutePath) {
     candidates.add(absolutePath);
-    if (!absolutePath.endsWith(".md")) {
-        candidates.add(`${absolutePath}.md`);
-    }
+    candidates.add(`${absolutePath}.md`);
+}
+function addPathCandidateIfInside(candidates, compiledRoot, absolutePath) {
+    const root = resolve(compiledRoot);
+    const candidate = resolve(absolutePath);
+    if (candidate !== root && !candidate.startsWith(`${root}/`))
+        return;
+    addPathCandidate(candidates, candidate);
 }
 function compiledZoneDirectoryPaths(compiledRoot) {
-    const workflowRoot = workflowPackagePathForCompiled(compiledRoot);
-    const schema = readCompiledSchemaFile(workflowRoot);
+    const methodRoot = methodPackagePathForCompiled(compiledRoot);
+    const schema = readCompiledSchemaFile(methodRoot);
     if (!schema)
         return new Map();
     return new Map(schema.zones
@@ -246,4 +254,4 @@ function addFrontmatterLinkTarget(targets, value) {
         }
     }
 }
-export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
+export { validateCompiled, validateCompiledStage, validateCompiledMethod, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";

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

@@ -0,0 +1,2 @@
+export * as schema from "./lib/schema.js";
+export type { MethodId, PreparationName, ReadinessCheck, ReadinessGate, ReadinessState, ReadinessStatus, ReadinessTargetResult, RuntimeContractType, RuntimeExecutorInfo, RuntimeStage, RuntimeTargetType, TestCaseExpect, TestTargetType, } from "./lib/schema.js";

package/dist/packages/contracts/index.js

@@ -0,0 +1 @@
+export * as schema from "./lib/schema.js";