@interf/compiler 0.7.3 → 0.9.1

package/dist/packages/agents/lib/shells.js

@@ -58,21 +58,21 @@ export function renderCompiledAgents(compiledPath, name, workflowId, about, opti
         "",
         "## How this portable context works",
         "",
-        "- The workflow package defines the context interface this portable context implements on disk.",
-        "- `.interf/interf.json` points to the local `raw/` snapshot via `source.path` and back to the project root via `source.control_path`.",
-        `- Workflow seed: \`${workflowOriginSelected}\`.`,
+        "- The Method package defines the context interface this portable context implements on disk.",
+        "- `.interf/interf.json` points to the local `raw/` snapshot via `source.path` and back to the Interf Workspace via `source.control_path`.",
+        `- Method seed: \`${workflowOriginSelected}\`.`,
         ...(workflowLocalDraft
-            ? ["- This portable context now carries a local workflow draft improved from that seed. Recompiling this portable context reuses the local `.interf/workflow/` package."]
+            ? ["- This portable context now carries a local Method draft improved from that seed. Recompiling this portable context reuses the local `.interf/method/` package."]
             : []),
-        `- Active local workflow id: \`${workflowId}\`.`,
-        "- `.interf/workflow/` is the local editable method package for this portable context.",
-        `- \`.interf/workflow/${WORKFLOW_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
-        "- `.interf/workflow/improve/` is the editable source for workflow-improvement loops.",
-        "- `.interf/workflow/use/query/` is the editable source for the generated native query shell.",
-        "- `.interf/workflow/compile/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
+        `- Active local Method id: \`${workflowId}\`.`,
+        "- `.interf/method/` is the local editable Method package for this portable context.",
+        `- \`.interf/method/${WORKFLOW_SCHEMA_FILE}\` is the deterministic context interface for this portable context.`,
+        "- `.interf/method/improve/` is the editable source for Method-improvement loops.",
+        "- `.interf/method/use/query/` is the editable source for the generated native query shell.",
+        "- `.interf/method/compile/stages/` defines stage-specific docs that Interf projects into native execution shells for automated runs.",
         "- Native local query skills are generated under local agent skill directories such as `.claude/skills/` and `.codex/skills/`.",
         "- `raw/` contains the local raw snapshot used for evidence and verification.",
-        `- Workflow zones are declared in \`.interf/workflow/${WORKFLOW_SCHEMA_FILE}\`.`,
+        `- Method zones are declared in \`.interf/method/${WORKFLOW_SCHEMA_FILE}\`.`,
         ...zoneLines,
         "- `.interf/runtime/` holds runtime artifacts written by Interf.",
         "- `.interf/tests/` mirrors the latest saved comparison and keeps detailed target runs plus preserved sandboxes.",
@@ -80,9 +80,9 @@ export function renderCompiledAgents(compiledPath, name, workflowId, about, opti
         "",
         "## Manual query rules",
         "",
-        "- Prefer the workflow-declared context outputs before `raw/`.",
-        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/workflow/use/query/SKILL.md`.",
-        "- Treat `.interf/` as method/runtime metadata, not answer evidence, unless explicitly asked to inspect workflow or test history.",
+        "- Prefer the Method-declared context outputs before `raw/`.",
+        "- Use the generated native `interf-query` skill for manual querying. The editable source lives at `.interf/method/use/query/SKILL.md`.",
+        "- Treat `.interf/` as method/runtime metadata, not answer evidence, unless explicitly asked to inspect Method or test history.",
         "- Use `raw/` for quotes, verification, ambiguity, or evidence the portable context does not expose well.",
         "- If exact chart, table, or image-derived evidence matters, inspect the raw source and say whether the answer was text-derived, table-derived, or chart-derived.",
         "",
@@ -111,16 +111,16 @@ export function renderCompiledQuerySkill() {
         "This file is the editable authoring source for the generated native local `interf-query` skill.",
         "",
         "Default loop:",
-        "1. Read `workflow/README.md` and this file first.",
-        `2. Use the workflow zones declared in \`workflow/${WORKFLOW_SCHEMA_FILE}\` before falling back to \`raw/\`.`,
+        "1. Read `.interf/method/README.md` and this file first.",
+        `2. Use the Method zones declared in \`.interf/method/${WORKFLOW_SCHEMA_FILE}\` before consulting \`raw/\`.`,
         "3. Use `raw/` for direct quotes, verification, exact lookups, and cases where the portable context is missing the needed evidence or is ambiguous.",
         "",
         "Answering rule:",
         "- do not modify files under `raw/`",
-        "- treat the workflow as the method layer and the portable-context zones as the working retrieval surface",
+        "- treat the Method as the portable-context contract and use its zones as the working retrieval surface",
         "- say explicitly when an answer depends on approximation, bounded inference, or a raw-source re-check",
         "- use `raw/` to confirm source page, metric family, provenance, or exact wording when the portable context is missing the needed evidence or is ambiguous",
-        "- do not invent navigation or note structure beyond what this workflow declares",
+        "- do not invent navigation or note structure beyond what this Method declares",
         "- when the portable context is insufficient, verify in `raw/` and then answer",
         "",
         "You can edit this file to bias manual question-answering behavior for this portable context.",
@@ -158,7 +158,7 @@ function renderRawTestQuerySkill() {
         "name: interf-query",
         "description: >",
         "  Native local query skill for an Interf raw test shell. Use it only",
-        "  to answer baseline questions directly from `raw/`.",
+        "  to answer source-files readiness checks directly from `raw/`.",
         "---",
         "",
         "# Interf Raw Test Query",
@@ -176,7 +176,7 @@ function renderRawTestQuerySkill() {
 function readCompiledQuerySkillSource(compiledPath) {
     const filePath = compiledQuerySkillSourcePath(compiledPath);
     if (!existsSync(filePath)) {
-        throw new Error(`Missing compiled query skill source at ${filePath}. Interf compile runs the local workflow package directly, so reseed or repair this compiled context instead of auto-healing query docs.`);
+        throw new Error(`Missing compiled query skill source at ${filePath}. Interf compile runs the local Method package directly, so reseed or repair this portable context instead of auto-healing query docs.`);
     }
     return readFileSync(filePath, "utf8").trim();
 }
@@ -331,9 +331,9 @@ function renderStageExecutionAgents(compiledName, workflowId, stage) {
         "- `inputs/<zone-id>/` = read mounts for the current stage.",
         "- `outputs/<zone-id>/` = write mounts for the current stage.",
         "- For file zones, `runtime/paths.json` points to the exact file path inside those mount roots.",
-        "- declared compiled zone paths are also projected at the shell root so workflow-relative contract paths stay valid.",
+        "- declared compiled zone paths are also projected at the shell root so Method-relative contract paths stay valid.",
         "- `runtime/` = stage contract and machine-readable path map for this shell.",
-        "- `workflow/` = workflow metadata, workflow schema, and docs for the current stage only.",
+        "- `method/` = Method metadata, workflow schema, and docs for the current stage only.",
         "",
         "## Boundaries",
         "",
@@ -381,7 +381,7 @@ function renderStageExecutionSkill(stage, stageMethodDoc) {
         `- contract type: \`${stage.contractType}\``,
         `- reads: ${stage.reads.join(", ")}`,
         `- writes: ${stage.writes.join(", ")}`,
-        `- editable source: \`workflow/compile/stages/${stage.skillDir}/SKILL.md\``,
+        `- editable source: \`method/compile/stages/${stage.skillDir}/SKILL.md\``,
         "",
         ...(stageMethodDoc
             ? [
@@ -399,14 +399,14 @@ function renderCompiledQueryNativeSkill(querySkillContent) {
         "name: interf-query",
         "description: >",
         "  Native local query skill for this portable context built by Interf.",
-        "  Use it for manual questions against the portable context and raw fallback.",
+        "  Use it for manual questions against the portable context and source files under raw/.",
         "---",
         "",
         "# Interf Query",
         "",
         "This is the native local query skill for portable context built by Interf.",
         "Use it when reading this portable context manually.",
-        "Editable source: `.interf/workflow/use/query/SKILL.md`.",
+        "Editable source: `.interf/method/use/query/SKILL.md`.",
         "",
         querySkillContent.trim(),
         "",
@@ -655,7 +655,7 @@ function freezePreservedShell(rootPath, shellType) {
 }
 export function renderClaudeBootstrap(content) {
     return [
-        "<!-- Generated compatibility mirror of AGENTS.md. Interf may rewrite this file. -->",
+        "<!-- Generated mirror of AGENTS.md. Interf may rewrite this file. -->",
         "",
         content.trimEnd(),
         "",
@@ -666,29 +666,33 @@ function renderWorkflowAuthoringAgents(options) {
         `# ${options.label} — Workflow Authoring Shell`,
         "",
         "This is an automated workflow-authoring shell generated by Interf.",
-        "It exists to create or refine one standalone workflow from the source data, desired portable-context outputs, and proof requirements in this task.",
+        "It exists to create one standalone workflow from the source data, desired portable-context outputs, and proof requirements in this task.",
         "",
         "## Start Here",
         "",
         "1. Read `runtime/authoring-context.json` now.",
         `2. Read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${WORKFLOW_SCHEMA_FILE}\` now.`,
-        "3. Review `artifacts/source-dataset/raw/` and `artifacts/preview-compiled/` if present.",
+        "3. Review `artifacts/source-dataset/raw/`.",
         "4. Use the local native `interf-workflow-author` skill now.",
         "",
         "## Boundaries",
         "",
         `- New workflow id: \`${options.workflowId}\`.`,
-        `- Seed workflow: \`${options.baseWorkflowId}\`.`,
+        "- Authoring mode: from scratch.",
+        ...(options.referenceWorkflowId
+            ? [`- Reference workflow id: \`${options.referenceWorkflowId}\` (context only, not a seed).`]
+            : []),
         "- Edit only files under `workflow/`.",
-        "- Do not edit raw files or preview artifacts.",
+        "- Do not edit source artifacts.",
         "- Keep the workflow valid for the current compiler API and workflow schema.",
-        "- For acceptance rules, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
+        "- For acceptance criteria, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
         "- 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.",
         "",
         "## Goal",
         "",
         "- produce one standalone workflow tuned to the source data, desired outputs, and checks in this task",
+        "- replace the neutral scaffold topology with the stage graph this work needs",
         "- define output zones and stage proof so Interf can show whether the data is ready",
         "- preserve deterministic stage and context-interface contracts",
         "- stop once the workflow edits are complete",
@@ -706,66 +710,25 @@ function renderWorkflowAuthoringSkill() {
         "# Interf Workflow Authoring",
         "",
         "Read `runtime/authoring-context.json` first.",
-        "Then review the seeded package under `workflow/`, the raw snapshot under `artifacts/source-dataset/raw/`, and any preview context outputs under `artifacts/preview-compiled/`.",
+        "Then review the neutral workflow scaffold under `workflow/` and the raw snapshot under `artifacts/source-dataset/raw/`.",
         "",
         "Rules:",
         "- edit only `workflow/`",
         `- keep \`workflow.json\`, \`${WORKFLOW_SCHEMA_FILE}\`, and any changed stage docs aligned`,
         "- use `zone_counts_at_least` for numeric fixed minimums; use `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`",
-        "- prefer small, defensible package edits over random churn",
-        "- keep the package standalone; do not introduce runtime inheritance or fallback assumptions",
+        "- design the stage graph from the source data and preparation-and-evidence brief",
+        "- replace the placeholder `prepare` stage unless that exact stage is truly the final method",
+        "- keep the package standalone; do not introduce runtime inheritance or hidden source-package assumptions",
         "- do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path",
         "- respect stage boundaries: do not make structure outputs link to notes or entrypoints first created by later stages",
         "- prefer conservative routing changes over speculative note sprawl",
         "- 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",
-        "- do not hardcode benchmark answers into workflow docs",
-        "- do not edit raw files or preview artifacts",
+        "- do not hardcode readiness-check answers into workflow docs",
+        "- do not edit source artifacts",
         "",
     ].join("\n");
 }
-function authoringCopyIfExists(sourcePath, targetPath) {
-    if (!existsSync(sourcePath))
-        return;
-    mkdirSync(dirname(targetPath), { recursive: true });
-    cpSync(sourcePath, targetPath, {
-        recursive: true,
-        force: true,
-        errorOnExist: false,
-        preserveTimestamps: true,
-    });
-}
-function projectCompiledPreviewSnapshot(previewCompiledPath, shellRoot) {
-    const previewRoot = join(shellRoot, "artifacts", "preview-compiled");
-    mkdirSync(previewRoot, { recursive: true });
-    authoringCopyIfExists(join(previewCompiledPath, "AGENTS.md"), join(previewRoot, "AGENTS.md"));
-    authoringCopyIfExists(join(previewCompiledPath, "CLAUDE.md"), join(previewRoot, "CLAUDE.md"));
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(previewCompiledPath));
-    for (const zone of schema?.zones ?? []) {
-        if (zone.kind === "runtime" || zone.role === "input")
-            continue;
-        const absolutePath = compiledZoneAbsolutePath(previewCompiledPath, zone);
-        if (!existsSync(absolutePath))
-            continue;
-        authoringCopyIfExists(absolutePath, join(previewRoot, zone.path));
-    }
-}
-function projectCompiledPreviewRuntime(previewCompiledPath, shellRoot) {
-    const targetRoot = join(shellRoot, "artifacts", "preview-runtime");
-    mkdirSync(targetRoot, { recursive: true });
-    const runtimeRoot = compiledRuntimeRoot(previewCompiledPath);
-    for (const artifactName of [
-        "run.json",
-        "state.json",
-        "health.json",
-        "view-spec.json",
-        "raw-snapshot.json",
-        "execution-shells",
-        "logs",
-    ]) {
-        authoringCopyIfExists(join(runtimeRoot, artifactName), join(targetRoot, artifactName));
-    }
-}
 function improvementWorkflowDocsPath(compiledPath) {
     return join(workflowPackagePathForCompiled(compiledPath), "improve");
 }
@@ -778,9 +741,10 @@ export function createWorkflowAuthoringShell(options) {
         kind: "interf-workflow-authoring",
         version: 1,
         generated_at: new Date().toISOString(),
+        authoring_mode: "from-scratch",
         workflow_id: options.workflowId,
         workflow_label: options.label,
-        seed_workflow_id: options.baseWorkflowId,
+        ...(options.referenceWorkflowId ? { reference_workflow_id: options.referenceWorkflowId } : {}),
         task_prompt: options.taskPrompt,
         dataset: {
             source_path: options.datasetPath,
@@ -792,17 +756,6 @@ export function createWorkflowAuthoringShell(options) {
                 })),
             },
         },
-        preview: options.preview
-            ? {
-                prepared: true,
-                compile_ok: options.preview.compileResult.ok,
-                failed_stage: options.preview.compileResult.failedStage,
-            }
-            : {
-                prepared: false,
-                compile_ok: null,
-                failed_stage: null,
-            },
     };
     writeFileSync(join(shellRoot, "runtime", "authoring-context.json"), `${JSON.stringify(context, null, 2)}\n`);
     projectRawSnapshot({
@@ -813,15 +766,11 @@ export function createWorkflowAuthoringShell(options) {
         prune: true,
         preserveTimestamps: true,
     });
-    if (options.preview) {
-        projectCompiledPreviewSnapshot(options.preview.compiledPath, shellRoot);
-        projectCompiledPreviewRuntime(options.preview.compiledPath, shellRoot);
-    }
     linkPath(options.workflowPath, join(shellRoot, "workflow"));
     writeNativeAgentSurface(shellRoot, renderWorkflowAuthoringAgents({
         workflowId: options.workflowId,
         label: options.label,
-        baseWorkflowId: options.baseWorkflowId,
+        referenceWorkflowId: options.referenceWorkflowId ?? null,
     }), "interf-workflow-author", renderWorkflowAuthoringSkill());
     return {
         rootPath: shellRoot,
@@ -854,7 +803,7 @@ function renderWorkflowImprovementAgents(compiledName, workflowId, loopIndex) {
         "- Do not edit checks, test specs, raw files, or generated context outputs.",
         "- Review context outputs under `artifacts/compiled-view/` and test/runtime evidence under `artifacts/`.",
         "- Keep the workflow valid for the current compiler API and workflow schema.",
-        "- For acceptance rules, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
+        "- For acceptance criteria, use `zone_counts_at_least` for numeric fixed minimums and `zone_counts_at_least_counts` only for runtime count-key strings such as `source_total`.",
         "",
         "## Goal",
         "",

package/dist/packages/agents/lib/types.d.ts

@@ -27,4 +27,5 @@ export interface SpawnAgentOptions {
     statusLogPath?: string | null;
     executionProfile?: WorkflowExecutionProfile;
     completionCheck?: (() => boolean) | null;
+    onStatus?: (line: string) => void;
 }

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

@@ -1,6 +1,8 @@
 export declare const COMPILED_INTERF_DIR = ".interf";
 export declare const COMPILED_CONFIG_FILE = "interf.json";
-export declare const COMPILED_WORKFLOW_DIR = "workflow";
+export declare const COMPILED_METHOD_DIR = "method";
+export declare const COMPILED_WORKFLOW_DIR = "method";
+export declare const LEGACY_COMPILED_WORKFLOW_DIR = "workflow";
 export declare const COMPILED_TEST_DIR = "tests";
 export declare const COMPILED_TEST_TARGETS_DIR = "targets";
 export declare const COMPILED_RUNTIME_DIR = "runtime";
@@ -17,6 +19,7 @@ export declare function compiledRuntimeFilePath(compiledPath: string, fileName:
 export declare function compiledInterfRoot(compiledPath: string): string;
 export declare function compiledInterfConfigPath(compiledPath: string): string;
 export declare function workflowPackagePathForCompiled(compiledPath: string): string;
+export declare function legacyWorkflowPackagePathForCompiled(compiledPath: string): string;
 export declare function testRootForCompiled(compiledPath: string): string;
 export declare function testTargetsRootForCompiled(compiledPath: string): string;
 export declare function stageExecutionShellsRoot(compiledPath: string): string;

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

@@ -1,7 +1,9 @@
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 export const COMPILED_INTERF_DIR = ".interf";
 export const COMPILED_CONFIG_FILE = "interf.json";
-export const COMPILED_WORKFLOW_DIR = "workflow";
+export const COMPILED_METHOD_DIR = "method";
+export const COMPILED_WORKFLOW_DIR = COMPILED_METHOD_DIR;
+export const LEGACY_COMPILED_WORKFLOW_DIR = "workflow";
 export const COMPILED_TEST_DIR = "tests";
 export const COMPILED_TEST_TARGETS_DIR = "targets";
 export const COMPILED_RUNTIME_DIR = "runtime";
@@ -28,6 +30,9 @@ export function compiledInterfConfigPath(compiledPath) {
 export function workflowPackagePathForCompiled(compiledPath) {
     return join(compiledInterfRoot(compiledPath), COMPILED_WORKFLOW_DIR);
 }
+export function legacyWorkflowPackagePathForCompiled(compiledPath) {
+    return join(compiledInterfRoot(compiledPath), LEGACY_COMPILED_WORKFLOW_DIR);
+}
 export function testRootForCompiled(compiledPath) {
     return join(compiledInterfRoot(compiledPath), COMPILED_TEST_DIR);
 }
@@ -91,6 +96,7 @@ export function resolveSourceControlPathForCompiled(compiledPath) {
         const parent = dirname(cursor);
         if (basename(parent) === "interf" &&
             basename(cursor) !== "tests" &&
+            basename(cursor) !== "methods" &&
             basename(cursor) !== "workflows") {
             return dirname(parent);
         }

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

@@ -1,6 +1,7 @@
 import { type WorkflowExecutor } from "../agents/lib/executors.js";
 import { type WorkflowReporter, type WorkflowStageResult } from "../workflow-package/workflow-helpers.js";
 import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
+import type { RunEventSink } from "../execution/events.js";
 export interface CompiledSummarizeResult extends WorkflowStageResult {
     skipped: boolean;
     plan: {
@@ -23,6 +24,8 @@ export declare function runCompiledSummarize(options: {
     reportStep?: boolean;
     stageDefinition?: CompiledStageExecutionDefinition;
     fullPass?: boolean;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<CompiledSummarizeResult>;
 export declare function runCompiledCompile(options: {
     executor: WorkflowExecutor;
@@ -30,10 +33,14 @@ export declare function runCompiledCompile(options: {
     reporter?: WorkflowReporter;
     reportStep?: boolean;
     preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<WorkflowStageResult>;
 export declare function compileCompiled(options: {
     executor: WorkflowExecutor;
     compiledPath: string;
     reporter?: WorkflowReporter;
     preserveStageShells?: StageShellRetentionMode;
+    runId?: string;
+    events?: RunEventSink;
 }): Promise<CompiledCompileResult>;

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

@@ -1,4 +1,3 @@
-import { join } from "node:path";
 import { refreshCompiledBootstrapGuidance, } from "../agents/lib/compiled-bootstrap.js";
 import { validateWorkflowPackage } from "../workflow-package/local-workflows.js";
 import { reportValidationFailure, } from "../workflow-package/workflow-helpers.js";
@@ -9,6 +8,7 @@ import { compiledExecutionStages, resolveCompiledContext, } from "./compiled-tar
 import { discoverSourceFiles } from "./discovery.js";
 import { runCompiledStage } from "./compiled-stage-runner.js";
 import { resolveSourceInputPath } from "../project-model/interf-detect.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 export async function runCompiledSummarize(options) {
     const context = resolveCompiledContext(options.compiledPath);
     const stageDefinition = options.stageDefinition
@@ -29,6 +29,8 @@ export async function runCompiledSummarize(options) {
         reporter: options.reporter,
         reportStep: options.reportStep,
         stageDefinition,
+        runId: options.runId,
+        events: options.events,
     });
     return {
         ...result,
@@ -48,13 +50,18 @@ export async function runCompiledCompile(options) {
     let lastResult = { ok: true, code: 0 };
     try {
         const context = resolveCompiledContext(options.compiledPath);
-        for (const stageDefinition of compiledExecutionStages(context.workflowId, options.compiledPath)) {
+        const stages = compiledExecutionStages(context.workflowId, options.compiledPath);
+        for (const [index, stageDefinition] of stages.entries()) {
             const result = await runCompiledStage({
                 executor: options.executor,
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: options.reportStep,
                 stageDefinition,
+                runId: options.runId,
+                events: options.events,
+                stageIndex: index,
+                stageTotal: stages.length,
             });
             lastResult = result;
             if (!result.ok)
@@ -82,7 +89,7 @@ export async function compileCompiled(options) {
         const sourceInputPath = resolveSourceInputPath(options.compiledPath);
         syncCompiledRawSnapshot(options.compiledPath, sourceInputPath);
         refreshCompiledBootstrapGuidance(options.compiledPath);
-        const workflowValidation = validateWorkflowPackage(join(options.compiledPath, ".interf", "workflow"));
+        const workflowValidation = validateWorkflowPackage(workflowPackagePathForCompiled(options.compiledPath));
         if (!workflowValidation.ok) {
             reportValidationFailure(options.reporter, workflowValidation.summary, workflowValidation.errors);
             return {
@@ -101,13 +108,17 @@ export async function compileCompiled(options) {
         }
         const context = resolveCompiledContext(options.compiledPath);
         const stages = compiledExecutionStages(context.workflowId, options.compiledPath);
-        for (const stageDefinition of stages) {
+        for (const [index, stageDefinition] of stages.entries()) {
             const stageResult = await runCompiledStage({
                 executor: options.executor,
                 compiledPath: options.compiledPath,
                 reporter: options.reporter,
                 reportStep: true,
                 stageDefinition,
+                runId: options.runId,
+                events: options.events,
+                stageIndex: index,
+                stageTotal: stages.length,
             });
             result.stageResults[stageDefinition.id] = stageResult;
             if (!stageResult.ok) {

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

@@ -18,7 +18,7 @@ export function workflowSchemaExists(rootPath) {
     return existsSync(workflowSchemaFilePath(rootPath));
 }
 export function workflowSchemaRelativePath() {
-    return `workflow/${WORKFLOW_SCHEMA_FILE}`;
+    return `method/${WORKFLOW_SCHEMA_FILE}`;
 }
 export function listCompiledSchemaZones(schema) {
     return [...schema.zones];

package/dist/packages/compiler/compiled-stage-plan.d.ts

@@ -1,5 +1,5 @@
 import { type RuntimeStageContractDraft } from "./runtime.js";
-import { type CompiledWorkflowId, type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
+import { type WorkflowStageDefinition } from "../workflow-package/workflow-definitions.js";
 import { resolveCompiledContext, type CompiledStageExecutionDefinition } from "./compiled-target.js";
 import type { RuntimeStageInstructions } from "./lib/schema.js";
 export declare function resolveStageContractArtifacts(compiledPath: string, stageDefinition: Pick<WorkflowStageDefinition, "id" | "reads" | "writes">): {
@@ -7,7 +7,7 @@ export declare function resolveStageContractArtifacts(compiledPath: string, stag
     writes: string[];
 };
 export declare function buildStageCounts(compiledPath: string, stageDefinition: WorkflowStageDefinition): Record<string, number>;
-export declare function buildStageContract(compiledPath: string, workflowId: CompiledWorkflowId, stageDefinition: WorkflowStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;
+export declare function buildStageContract(compiledPath: string, stageDefinition: WorkflowStageDefinition, instructions: RuntimeStageInstructions): RuntimeStageContractDraft;
 export declare function buildCompiledStageExecutionPlan(compiledPath: string, stageDefinition: CompiledStageExecutionDefinition): {
     context: ReturnType<typeof resolveCompiledContext>;
     contract: RuntimeStageContractDraft;

package/dist/packages/compiler/compiled-stage-plan.js

@@ -51,7 +51,7 @@ export function buildStageCounts(compiledPath, stageDefinition) {
         ...zoneCounts,
     };
 }
-export function buildStageContract(compiledPath, workflowId, stageDefinition, instructions) {
+export function buildStageContract(compiledPath, stageDefinition, instructions) {
     const config = readInterfConfig(compiledPath);
     const stageArtifacts = resolveStageContractArtifacts(compiledPath, stageDefinition);
     return buildRuntimeStageContract({
@@ -61,10 +61,10 @@ export function buildStageContract(compiledPath, workflowId, stageDefinition, in
         counts: buildStageCounts(compiledPath, stageDefinition),
         stageReadArtifacts: stageArtifacts.reads,
         stageWriteArtifacts: stageArtifacts.writes,
-        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, workflowId, stageDefinition.id),
+        workflowNotes: getActiveCompiledStagePolicyNotes(compiledPath, stageDefinition.id),
         localSkillDocs: instructions.local_docs,
         instructions,
-        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, workflowId, stageDefinition.id),
+        acceptance: resolveActiveCompiledStageAcceptance(compiledPath, stageDefinition.id),
     });
 }
 export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {
@@ -74,6 +74,6 @@ export function buildCompiledStageExecutionPlan(compiledPath, stageDefinition) {
     return {
         context,
         instructions,
-        contract: buildStageContract(compiledPath, context.workflowId, stageDefinition, instructions),
+        contract: buildStageContract(compiledPath, stageDefinition, instructions),
     };
 }

package/dist/packages/compiler/compiled-stage-runner.d.ts

@@ -1,10 +1,15 @@
 import { type WorkflowExecutor } from "../agents/lib/executors.js";
 import { type WorkflowReporter, type WorkflowStageResult } from "../workflow-package/workflow-helpers.js";
 import { type CompiledStageExecutionDefinition } from "./compiled-target.js";
+import { type RunEventSink } from "../execution/events.js";
 export declare function runCompiledStage(options: {
     executor: WorkflowExecutor;
     compiledPath: string;
     reporter?: WorkflowReporter;
     reportStep?: boolean;
     stageDefinition: CompiledStageExecutionDefinition;
+    runId?: string;
+    events?: RunEventSink;
+    stageIndex?: number;
+    stageTotal?: number;
 }): Promise<WorkflowStageResult>;

package/dist/packages/compiler/compiled-stage-runner.js

@@ -6,16 +6,31 @@ import { executeValidatedStage, } from "../workflow-package/workflow-stage-runne
 import { formatActiveCompiledWorkflowStageStep, } from "../workflow-package/workflow-definitions.js";
 import { reportBlankLine, reportLine, } from "../workflow-package/workflow-helpers.js";
 import { buildCompiledStageExecutionPlan, } from "./compiled-stage-plan.js";
+import { createRunEventId, createRunEventTimestamp, } from "../execution/events.js";
+async function emitRunEvent(sink, event) {
+    await sink?.emit(event);
+}
 export async function runCompiledStage(options) {
     const stageDefinition = options.stageDefinition;
     const plan = buildCompiledStageExecutionPlan(options.compiledPath, stageDefinition);
     if (options.reportStep !== false) {
         reportBlankLine(options.reporter);
-        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, plan.context.workflowId, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
+        reportLine(options.reporter, `${formatActiveCompiledWorkflowStageStep(options.compiledPath, stageDefinition.id)} (${stageDefinition.description.toLowerCase()})`);
     }
     const shell = createStageExecutionShell(options.compiledPath, plan.context.compiledName, plan.context.workflowId, stageDefinition, plan.contract.artifacts.writes);
     try {
-        return await executeValidatedStage({
+        if (options.runId && options.events) {
+            await emitRunEvent(options.events, {
+                type: "stage.started",
+                event_id: createRunEventId("event"),
+                run_id: options.runId,
+                timestamp: createRunEventTimestamp(),
+                stage_id: stageDefinition.id,
+                ...(typeof options.stageIndex === "number" ? { stage_index: options.stageIndex } : {}),
+                ...(typeof options.stageTotal === "number" ? { stage_total: options.stageTotal } : {}),
+            });
+        }
+        const result = await executeValidatedStage({
             executor: options.executor,
             compiledPath: options.compiledPath,
             executionPath: shell.rootPath,
@@ -34,11 +49,44 @@ export async function runCompiledStage(options) {
             ],
             reporter: options.reporter,
             completionCheck: () => validateCompiledStage(options.compiledPath, stageDefinition.id).ok,
+            onStatus: options.runId && options.events
+                ? (line) => {
+                    void options.events?.emit({
+                        type: "log.appended",
+                        event_id: createRunEventId("event"),
+                        run_id: options.runId,
+                        timestamp: createRunEventTimestamp(),
+                        stage_id: stageDefinition.id,
+                        stream: "status",
+                        message: line,
+                    });
+                }
+                : undefined,
             syncWrites: () => syncStageExecutionShellWrites(options.compiledPath, shell.rootPath, stageDefinition, plan.contract.artifacts.writes),
             reconcile: () => reconcileCompiledStageRun(options.compiledPath, stageDefinition),
             refreshArtifacts: () => refreshCompiledArtifacts(options.compiledPath, { ensureViewSpec: true }),
             validate: () => validateCompiledStage(options.compiledPath, stageDefinition.id),
         });
+        if (options.runId && options.events) {
+            await emitRunEvent(options.events, result.ok
+                ? {
+                    type: "stage.passed",
+                    event_id: createRunEventId("event"),
+                    run_id: options.runId,
+                    timestamp: createRunEventTimestamp(),
+                    stage_id: stageDefinition.id,
+                    summary: result.summary ?? `${stageDefinition.label} completed.`,
+                }
+                : {
+                    type: "stage.failed",
+                    event_id: createRunEventId("event"),
+                    run_id: options.runId,
+                    timestamp: createRunEventTimestamp(),
+                    stage_id: stageDefinition.id,
+                    error: result.summary ?? `${stageDefinition.label} failed.`,
+                });
+        }
+        return result;
     }
     finally {
         freezeStageExecutionShell(shell.rootPath);

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

@@ -8,4 +8,4 @@ export declare function resolveCompiledContext(compiledPath: string): {
     controlPath: string;
     workflowId: CompiledWorkflowId;
 };
-export declare function compiledExecutionStages(workflowId: CompiledWorkflowId, compiledPath: string): CompiledStageExecutionDefinition[];
+export declare function compiledExecutionStages(_workflowId: CompiledWorkflowId, compiledPath: string): CompiledStageExecutionDefinition[];

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

@@ -10,7 +10,7 @@ export function resolveCompiledContext(compiledPath) {
         workflowId,
     };
 }
-export function compiledExecutionStages(workflowId, compiledPath) {
-    return getActiveCompiledWorkflow(compiledPath, workflowId)
+export function compiledExecutionStages(_workflowId, compiledPath) {
+    return getActiveCompiledWorkflow(compiledPath)
         .stages;
 }