@interf/compiler 0.7.2 → 0.9.1

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

@@ -1,28 +1,35 @@
-import { mkdtempSync, rmSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { rmSync } from "node:fs";
 import { createWorkflowAuthoringShell } from "../agents/lib/shells.js";
-import { seedLocalWorkflowPackageFromBase } from "../workflow-package/interf-workflow-package.js";
+import { createScratchLocalWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
 import { CONTEXT_INTERFACE_FILE } from "../workflow-package/context-interface.js";
 import { validateWorkflowPackage, workflowDefinitionPath } from "../workflow-package/local-workflows.js";
-import { createCompiled, compileCompiled } from "../compiler/workflows.js";
-import { projectRawSnapshot } from "../compiler/raw-snapshot.js";
 import { runWorkflowEditSession } from "./workflow-edit-session.js";
-import { copyDirectory } from "./lib/workflow-edit-utils.js";
 function buildWorkflowAuthoringPrompt() {
     return [
         "This is an automated Interf workflow-authoring run, not an open-ended chat session.",
         "Execute it now.",
-        "Create one standalone workflow for the files and checks in this source folder.",
+        "Create one standalone workflow for the source data, desired portable-context outputs, and proof requirements in this source folder.",
         "Read `runtime/authoring-context.json` first.",
+        "Treat `task_prompt` as the user's preparation-and-evidence brief: source data, output shape, and evidence that should show the data is ready.",
         `Then read \`workflow/README.md\`, \`workflow/workflow.json\`, and \`workflow/${CONTEXT_INTERFACE_FILE}\`.`,
-        "Review `artifacts/source-dataset/raw/` and any `artifacts/preview-compiled/` notes before editing the package.",
+        "The workflow directory starts as a neutral scaffold, not as a suggested workflow.",
+        "Replace the scaffold purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the method this work actually needs.",
+        "Review `artifacts/source-dataset/raw/` before editing the package.",
         "Prefer direct file-reading and search tools over shell commands for routine file inspection.",
         "Do not use shell helpers like `cat`, `sed`, `ls`, or `find` when a native read/search tool can inspect the same files.",
         "Edit only files under `workflow/`.",
         "Keep the workflow valid for the current compiler API and workflow schema.",
-        "Make the package materially more specific to this dataset task than the seeded base workflow. A no-op copy is not acceptable.",
+        "Choose stage ids, stage order, reads, writes, acceptance criteria, and stage docs from the source data and preparation-and-evidence brief.",
+        "Do not preserve the placeholder `prepare` stage unless the final workflow genuinely needs a stage with that exact role.",
+        "When editing acceptance criteria: `zone_counts_at_least` maps declared zone ids to fixed numeric minimums.",
+        "`zone_counts_at_least_counts` also maps declared zone ids to runtime count-key strings such as `source_total`; `source_total` is a value, never a zone key.",
+        "Before stopping, verify every acceptance zone key is declared in `workflow.schema.json`.",
+        "For every stage in `workflow.json`, create `workflow/compile/stages/<skill_dir>/SKILL.md` and make the folder name exactly match that stage's `skill_dir`.",
+        "Every zone path in `workflow.schema.json` must be unique and non-overlapping. Do not declare both `knowledge/indexes` and `knowledge/indexes/some-file.md` as separate zones.",
+        "Make the package materially specific to this dataset task, output shape, and proof requirement. A no-op scaffold is not acceptable.",
         "Treat the workflow package as four aligned layers: purpose, inputs, context interface, and stages.",
+        "Keep the portable-context entrypoint canonical: if the Method writes an agent entrypoint, declare zone id `home` with path `home.md` and make the final shaping stage own it.",
+        "Do not move the main entrypoint to `knowledge/home.md` or any other nested path.",
         "Prefer explicit stage-doc, stage-policy, purpose, input-contract, and context-interface edits over vague rewrites.",
         "Do not introduce wikilinks unless the workflow also creates the target note by exact basename or explicit relative path.",
         "Respect stage boundaries: a stage may only introduce links that resolve within that stage's declared writes or already-existing read zones.",
@@ -33,88 +40,42 @@ function buildWorkflowAuthoringPrompt() {
         "As soon as the workflow edits are complete, stop.",
     ].join("\n");
 }
-async function prepareWorkflowAuthoringPreview(options) {
-    const tempRoot = mkdtempSync(join(tmpdir(), "interf-workflow-preview-"));
-    projectRawSnapshot({
-        sourcePath: options.datasetPath,
-        destinationPath: tempRoot,
-        compiledPath: tempRoot,
-        mode: "copy",
-        prune: true,
-        preserveTimestamps: true,
-    });
-    copyDirectory(options.workflowPath, workflowDefinitionPath(tempRoot, options.workflowId));
-    const compiledPath = createCompiled("preview", tempRoot, options.workflowId, options.about, tempRoot);
-    const result = await compileCompiled({
-        executor: options.executor,
-        compiledPath,
-        ...(options.reporter ? { reporter: options.reporter } : {}),
-        preserveStageShells: "on-failure",
-    });
-    return {
-        tempRoot,
-        compiledPath,
-        compileResult: {
-            ok: result.ok,
-            failedStage: result.failedStage,
-        },
-    };
-}
 export async function runWorkflowAuthoringDraft(options) {
-    const workflowPath = seedLocalWorkflowPackageFromBase({
+    const workflowPath = createScratchLocalWorkflowPackage({
         sourcePath: options.sourcePath,
-        baseWorkflowId: options.baseWorkflowId,
         workflowId: options.workflowId,
         label: options.label,
         hint: options.hint,
     });
-    let preview = null;
-    try {
-        if (options.preparePreview !== false) {
-            preview = await prepareWorkflowAuthoringPreview({
-                datasetPath: options.datasetPath,
-                about: options.taskPrompt,
-                workflowId: options.workflowId,
-                workflowPath,
-                executor: options.executor,
-                reporter: options.previewReporter ?? null,
-            });
-        }
-        const shell = createWorkflowAuthoringShell({
-            workflowPath,
-            workflowId: options.workflowId,
-            label: options.label,
-            baseWorkflowId: options.baseWorkflowId,
-            datasetPath: options.datasetPath,
-            taskPrompt: options.taskPrompt,
-            checks: options.checks ?? [],
-            preview,
-        });
-        if (preview) {
-            rmSync(preview.tempRoot, { recursive: true, force: true });
-            preview = null;
-        }
-        const session = await runWorkflowEditSession({
-            executor: options.executor,
-            workflowPath,
-            shell,
-            prompt: buildWorkflowAuthoringPrompt(),
-            validate: validateWorkflowPackage,
-        });
-        return {
-            status: session.status,
-            changed: session.changed,
-            summary: session.summary,
-            validation: session.validation,
-            workflowPath,
-            shellPath: shell.rootPath,
-        };
-    }
-    finally {
-        if (preview) {
-            rmSync(preview.tempRoot, { recursive: true, force: true });
-        }
+    const shell = createWorkflowAuthoringShell({
+        workflowPath,
+        workflowId: options.workflowId,
+        label: options.label,
+        referenceWorkflowId: options.baseWorkflowId ?? null,
+        datasetPath: options.datasetPath,
+        taskPrompt: options.taskPrompt,
+        checks: options.checks ?? [],
+    });
+    const session = await runWorkflowEditSession({
+        executor: options.executor,
+        workflowPath,
+        shell,
+        prompt: buildWorkflowAuthoringPrompt(),
+        validate: validateWorkflowPackage,
+        maxValidationRepairAttempts: 1,
+        onStatus: options.onStatus,
+    });
+    if (session.status !== "updated") {
+        rmSync(workflowPath, { recursive: true, force: true });
     }
+    return {
+        status: session.status,
+        changed: session.changed,
+        summary: session.summary,
+        validation: session.validation,
+        workflowPath,
+        shellPath: shell.rootPath,
+    };
 }
 export function resolveWorkflowDraftPath(sourcePath, workflowId) {
     return workflowDefinitionPath(sourcePath, workflowId);

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

@@ -13,4 +13,6 @@ export declare function runWorkflowEditSession(options: {
     shell: WorkflowEditShellArtifacts;
     prompt: string;
     validate: (workflowPath: string) => WorkflowValidationResult;
+    maxValidationRepairAttempts?: number;
+    onStatus?: (line: string) => void;
 }): Promise<WorkflowEditSessionResult>;

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

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

package/dist/packages/workflow-authoring/workflow-improvement.js

@@ -42,7 +42,7 @@ function buildLoopContext(options) {
         max_loops: options.maxLoops,
         max_attempts: options.maxAttempts,
         review_paths: resolveWorkflowImprovementReviewPaths(options.compiledPath),
-        truth_checks: {
+        readiness_checks: {
             count: options.compiledConfig.checks.length,
             questions: options.compiledConfig.checks.map((check, index) => ({
                 id: check.id ?? `check-${index + 1}`,
@@ -167,6 +167,7 @@ export async function runWorkflowImprovementLoop(options) {
         shell,
         prompt: buildWorkflowImprovementPrompt(),
         validate: validateWorkflowPackage,
+        maxValidationRepairAttempts: 1,
     });
     const preservedShellManifestPath = freezeWorkflowImprovementShell(shell.rootPath);
     writeWorkflowImprovementRunLedger(options.compiledPath, options.runId, buildWorkflowImprovementLoopRecord({

package/dist/packages/workflow-package/context-interface.js

@@ -13,7 +13,7 @@ export const ContextInterfaceSchema = WorkflowCompiledSchemaSchema;
 export const ContextInterfaceZoneSchema = WorkflowCompiledZoneSchema;
 export const ContextInterfaceZoneIdSchema = WorkflowZoneIdSchema;
 export const ContextInterfaceZoneRoleSchema = WorkflowZoneRoleSchema;
-// Package-owned input contract for authoring, review, and future Studio flows.
+// Package-owned input contract for authoring, review, and future authoring flows.
 // This does not change compiler execution semantics; it describes what data a
 // workflow expects to organize before the compiler materializes the context
 // interface on disk.
@@ -54,7 +54,7 @@ export function contextInterfaceExists(rootPath) {
     return existsSync(contextInterfaceFilePath(rootPath));
 }
 export function contextInterfaceRelativePath() {
-    return `workflow/${CONTEXT_INTERFACE_FILE}`;
+    return `method/${CONTEXT_INTERFACE_FILE}`;
 }
 export function listContextInterfaceZones(contextInterface) {
     return [...contextInterface.zones];

package/dist/packages/workflow-package/interf-workflow-package.d.ts

@@ -23,3 +23,9 @@ export declare function seedLocalWorkflowPackageFromBase(options: {
     label: string;
     hint: string;
 }): string;
+export declare function createScratchLocalWorkflowPackage(options: {
+    sourcePath: string;
+    workflowId: string;
+    label: string;
+    hint: string;
+}): string;

package/dist/packages/workflow-package/interf-workflow-package.js

@@ -135,7 +135,7 @@ function renderWorkflowReadme(workflow) {
         "",
         stageLines,
         "",
-        "Interf runs the local copy of this package directly from `.interf/workflow/` inside each compiled context.",
+        "Interf runs the local copy of this package directly from `.interf/method/` inside each portable context.",
         "",
     ].join("\n");
 }
@@ -145,9 +145,10 @@ function renderDerivedWorkflowReadme(options) {
         "",
         options.hint,
         "",
-        `This workflow package was copied from \`${options.baseWorkflowId}\` and materialized as a standalone package for this kind of work.`,
+        `This workflow package was forked from \`${options.baseWorkflowId}\` and materialized as a standalone package for this kind of work.`,
+        "It starts with that workflow's topology; edit the package when the work needs different stages, zones, or proof.",
         "",
-        "Interf runs the local copy of this package directly. Keep purpose, inputs, context interface, and stage docs self-contained in this folder instead of relying on runtime inheritance or fallback.",
+        "Interf runs the local copy of this package directly. Keep purpose, inputs, context interface, and stage docs self-contained in this folder instead of relying on runtime inheritance.",
         "",
         "## Emphasis",
         "",
@@ -163,9 +164,23 @@ function renderSeedWorkflowReadme(options) {
         "",
         options.hint,
         "",
-        `This workflow package was seeded from \`${options.baseWorkflowId}\` as a standalone local draft.`,
+        `This workflow package was forked from \`${options.baseWorkflowId}\` as a standalone local package.`,
+        "It starts with that workflow's topology; edit the package when the work needs different stages, zones, or proof.",
         "",
-        "Interf runs the local copy of this package directly. Refine purpose, inputs, context interface, and stage instructions in this folder instead of relying on inheritance or runtime fallback.",
+        "Interf runs the local copy of this package directly. Refine purpose, inputs, context interface, and stage instructions in this folder instead of relying on inheritance.",
+        "",
+    ].join("\n");
+}
+function renderScratchWorkflowReadme(options) {
+    return [
+        `# ${options.label}`,
+        "",
+        options.hint,
+        "",
+        "This workflow package is a neutral from-scratch authoring scaffold.",
+        "",
+        "It is not copied from `interf-default`, and its placeholder stage is not a recommended topology.",
+        "Replace purpose, inputs, context interface, stages, stage docs, proof rules, and query guidance with the workflow this source data and task actually need.",
         "",
     ].join("\n");
 }
@@ -181,13 +196,13 @@ function renderImproveSkill(workflow) {
         "Default loop:",
         "1. Read the loop context first.",
         "2. Review preserved stage shells, runtime logs, and saved test runs from failed attempts.",
-        "3. Edit only the local workflow package for this compiled context to create a better workflow variation for this kind of work.",
+        "3. Edit only the local Method package for this portable context to create a better Method variation for this kind of work.",
         `4. Keep purpose, inputs, \`workflow.json\`, \`${CONTEXT_INTERFACE_FILE}\`, and any changed stage docs aligned.`,
         "",
         "Guardrails:",
         "- do not edit checks, test specs, or raw files",
         "- do not hardcode expected answers into workflow docs",
-        "- keep this package standalone; do not add or rely on runtime `extends` or fallback behavior",
+        "- keep this package standalone; do not add or rely on runtime `extends`",
         "- keep the workflow stack coherent: purpose, inputs, context interface, and stages should describe the same job",
         "- prefer small, defensible workflow changes over random churn",
         "",
@@ -291,7 +306,7 @@ export function seedCompiledWorkflowPackage(options) {
     const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, resolvedWorkflow.id);
     if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
         // Portable seed packages can be copied directly because compile runs the
-        // local package folder without any source-root fallback.
+        // local package folder without reading source-root workflow packages.
         copyWorkflowPackageDirectory(sourceWorkflowPath, workflowPackagePath(options.compiledPath));
         patchWorkflowPackageMetadata(workflowPackagePath(options.compiledPath), {
             id: resolvedWorkflow.id,
@@ -387,3 +402,95 @@ export function seedLocalWorkflowPackageFromBase(options) {
     writeWorkflowPackageToDir(targetPath, localWorkflow);
     return targetPath;
 }
+export function createScratchLocalWorkflowPackage(options) {
+    const targetPath = workflowDefinitionPath(options.sourcePath, options.workflowId);
+    const workflow = {
+        id: options.workflowId,
+        compilerApi: {
+            kind: "compiled",
+            version: 1,
+        },
+        purpose: {
+            label: "From-scratch workflow draft",
+            taskHint: "Replace this neutral scaffold with the workflow stages, outputs, and proof rules this work requires.",
+        },
+        inputs: [
+            {
+                id: "raw",
+                label: "Raw",
+                description: "Source-folder raw snapshot copied into the Preparation for direct evidence and verification.",
+                required: true,
+            },
+        ],
+        label: options.label,
+        hint: options.hint,
+        recommended: false,
+        scope: "local",
+        contextInterface: {
+            kind: "workflow-schema",
+            version: 1,
+            target_type: "compiled",
+            label: `${options.label} workflow schema`,
+            zones: [
+                {
+                    id: "raw",
+                    role: "input",
+                    path: "raw",
+                    kind: "directory",
+                    required: true,
+                    owned_by: [],
+                    description: "Source-folder raw snapshot copied into the Preparation for direct evidence and verification.",
+                },
+                {
+                    id: "draft-context",
+                    role: "output",
+                    path: "draft",
+                    kind: "directory",
+                    required: true,
+                    owned_by: ["prepare"],
+                    description: "Temporary placeholder output zone for the neutral authoring scaffold. Replace it with task-specific output zones.",
+                },
+                {
+                    id: "runtime",
+                    role: "runtime",
+                    path: ".interf/runtime",
+                    kind: "runtime",
+                    required: true,
+                    owned_by: [],
+                    description: "CLI-owned runtime state, health, stage contracts, and proof artifacts.",
+                },
+            ],
+        },
+        stages: [
+            {
+                id: "prepare",
+                label: "Prepare",
+                description: "Neutral placeholder stage for workflow authoring. Replace this stage with the topology this work needs.",
+                contractType: "workflow-draft-stage",
+                skillDir: "prepare",
+                reads: ["raw", "runtime"],
+                writes: ["draft-context"],
+                acceptance: {
+                    stage_truthy: ["finished_at"],
+                },
+            },
+        ],
+        stagePolicyNotes: {
+            prepare: [
+                "This is a neutral authoring scaffold, not a recommended workflow topology.",
+                "Replace this stage, output zone, and proof rule when drafting the final workflow.",
+            ],
+        },
+        starterDocs: [
+            {
+                relativePath: "README.md",
+                content: renderScratchWorkflowReadme({
+                    label: options.label,
+                    hint: options.hint,
+                }),
+            },
+        ],
+    };
+    writeWorkflowPackageToDir(targetPath, workflow);
+    return targetPath;
+}

package/dist/packages/workflow-package/local-workflows.js

@@ -33,6 +33,9 @@ const LocalWorkflowDefinitionSchema = z.object({
     stage_policy_notes: z.record(z.string(), z.array(z.string())).optional(),
 });
 function workflowRootPath(sourcePath) {
+    return join(sourcePath, "interf", "methods");
+}
+function legacyWorkflowRootPath(sourcePath) {
     return join(sourcePath, "interf", "workflows");
 }
 function builtinWorkflowRootPath(workflowId) {
@@ -41,6 +44,9 @@ function builtinWorkflowRootPath(workflowId) {
 export function workflowDefinitionPath(sourcePath, id) {
     return join(workflowRootPath(sourcePath), id);
 }
+function legacyWorkflowDefinitionPath(sourcePath, id) {
+    return join(legacyWorkflowRootPath(sourcePath), id);
+}
 function isSupportedWorkflowStarterDocPath(relativePath) {
     if (relativePath === "README.md")
         return true;
@@ -110,30 +116,36 @@ export function loadWorkflowDefinitionFromDir(dirPath) {
     };
 }
 export function listLocalWorkflowDefinitions(sourcePath) {
-    const root = workflowRootPath(sourcePath);
-    if (!existsSync(root))
-        return [];
-    return readdirSync(root)
-        .map((entry) => join(root, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch {
-            return false;
+    const definitions = new Map();
+    for (const root of [legacyWorkflowRootPath(sourcePath), workflowRootPath(sourcePath)]) {
+        if (!existsSync(root))
+            continue;
+        for (const entryPath of readdirSync(root).map((entry) => join(root, entry))) {
+            try {
+                if (!statSync(entryPath).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const definition = loadWorkflowDefinitionFromDir(entryPath);
+            if (definition)
+                definitions.set(definition.id, definition);
         }
-    })
-        .map((entryPath) => loadWorkflowDefinitionFromDir(entryPath))
-        .filter((definition) => definition !== null)
-        .sort((a, b) => a.label.localeCompare(b.label));
+    }
+    return [...definitions.values()].sort((a, b) => a.label.localeCompare(b.label));
 }
 export function loadLocalWorkflowDefinition(sourcePath, id) {
-    return loadWorkflowDefinitionFromDir(workflowDefinitionPath(sourcePath, id));
+    return (loadWorkflowDefinitionFromDir(workflowDefinitionPath(sourcePath, id)) ??
+        loadWorkflowDefinitionFromDir(legacyWorkflowDefinitionPath(sourcePath, id)));
 }
 export function resolveWorkflowPackageSourcePath(sourcePath, workflowId) {
     const localPath = workflowDefinitionPath(sourcePath, workflowId);
     if (existsSync(join(localPath, "workflow.json")))
         return localPath;
+    const legacyLocalPath = legacyWorkflowDefinitionPath(sourcePath, workflowId);
+    if (existsSync(join(legacyLocalPath, "workflow.json")))
+        return legacyLocalPath;
     const builtinPath = builtinWorkflowRootPath(workflowId);
     if (existsSync(join(builtinPath, "workflow.json")))
         return builtinPath;
@@ -155,7 +167,11 @@ export function seedLocalDefaultWorkflow(options) {
         throw new Error(`Built-in "interf" workflow not found at ${builtinInterfPath}.`);
     }
     copyWorkflowPackageDirectory(builtinInterfPath, targetPath);
-    patchWorkflowPackageMetadata(targetPath, { id: workflowId });
+    patchWorkflowPackageMetadata(targetPath, {
+        id: workflowId,
+        label: "Built-in Interf Workflow",
+        hint: "Built-in file-processing workflow: summarize source-grounded evidence, structure cross-file connections, and shape portable context around the saved readiness checks.",
+    });
     return { workflowId, targetPath, alreadyExisted: false };
 }
 export function isWorkflowId(value) {

package/dist/packages/workflow-package/workflow-definitions.d.ts

@@ -61,7 +61,7 @@ export declare function listCompiledWorkflowChoices(sourcePath?: string): Workfl
 export declare function getCompiledWorkflow(workflowId: CompiledWorkflowId, options?: {
     sourcePath?: string;
 }): WorkflowDefinition<string>;
-export declare function getActiveCompiledWorkflow(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId): WorkflowDefinition<string>;
+export declare function getActiveCompiledWorkflow(compiledPath: string): WorkflowDefinition<string>;
 export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId | null;
 export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId | null;
 export declare function resolveRequiredCompiledWorkflowFromConfig(config: unknown, label?: string): CompiledWorkflowId;
@@ -75,8 +75,8 @@ export declare function getWorkflowStagePosition(workflowId: WorkflowId, stage:
     stages: string[];
 } | null;
 export declare function getWorkflowStages(workflowId: WorkflowId, sourcePath?: string): string[];
-export declare function getActiveCompiledStages(compiledPath: string, fallbackWorkflowId: WorkflowId): string[];
+export declare function getActiveCompiledStages(compiledPath: string): string[];
 export declare function getWorkflowStagePolicyNotes(workflowId: WorkflowId, stage: string, sourcePath?: string): string[];
-export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): string[];
-export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, fallbackWorkflowId: WorkflowId, stage: string): WorkflowStageDefinition["acceptance"] | undefined;
-export declare function formatActiveCompiledWorkflowStageStep(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId, stage: string): string;
+export declare function getActiveCompiledStagePolicyNotes(compiledPath: string, stage: string): string[];
+export declare function resolveActiveCompiledStageAcceptance(compiledPath: string, stage: string): WorkflowStageDefinition["acceptance"] | undefined;
+export declare function formatActiveCompiledWorkflowStageStep(compiledPath: string, stage: string): string;