@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/interf-scaffold.js

@@ -1,16 +1,17 @@
-import { mkdirSync, writeFileSync, } from "node:fs";
-import { basename, join } from "node:path";
-import { getWorkspaceWorkflow } from "./workflow-definitions.js";
-import { refreshWorkspaceArtifacts, saveState, initWorkspaceState, } from "./state.js";
-import { saveEmptyWorkspaceInventory } from "./state-io.js";
+import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
+import { basename, join, relative, sep } from "node:path";
+import { getCompiledWorkflow } from "./workflow-definitions.js";
+import { refreshCompiledArtifacts, saveState, initCompiledState, } from "./state.js";
+import { saveEmptyCompiledInventory } from "./state-io.js";
 import { writeObsidianDefaults } from "./obsidian.js";
-import { assertWorkspaceContainer, assertWritableTargetDir, assertWorkspaceName, } from "./interf-detect.js";
-import { refreshWorkspaceBootstrapGuidance } from "./interf-bootstrap.js";
-import { seedWorkspaceWorkflowPackage } from "./interf-workflow-package.js";
-import { syncWorkspaceRawSnapshot } from "./workspace-raw.js";
-import { findSourceWorkspaceConfig, loadSourceFolderConfig, saveWorkspaceInterfConfig, } from "./source-config.js";
-import { defaultControlPathForWorkspace } from "./workspace-paths.js";
-import { renderUncompiledWorkspaceHome } from "./workspace-home.js";
+import { assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
+import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
+import { compiledCompiledPathForDataset } from "./project-paths.js";
+import { syncCompiledRawSnapshot } from "./compiled-raw.js";
+import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "./compiled-schema.js";
+import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { defaultControlPathForCompiled, workflowPackagePathForCompiled } from "./compiled-paths.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
     ".codex/",
@@ -22,67 +23,99 @@ const DEFAULT_INTERFIGNORE = [
     ".obsidian/",
     "",
 ].join("\n");
-export function createWorkspace(name, sourcePath, workflowId = "interf", about) {
-    assertWorkspaceName(name, "Workspace");
-    const containerPath = assertWorkspaceContainer(sourcePath);
-    mkdirSync(containerPath, { recursive: true });
-    const workspacePath = join(containerPath, name);
-    assertWritableTargetDir(workspacePath, "Workspace");
-    mkdirSync(workspacePath, { recursive: true });
-    const savedWorkspace = findSourceWorkspaceConfig(loadSourceFolderConfig(sourcePath), name);
-    const selectedWorkflow = getWorkspaceWorkflow(workflowId, { sourcePath });
-    const resolvedAbout = about ?? savedWorkspace?.about;
-    saveWorkspaceInterfConfig(workspacePath, {
-        type: "workspace",
+const UNCOMPILED_COMPILED_PLACEHOLDER = "Not yet compiled. Run `interf compile` to build the compiled dataset.";
+function renderUncompiledCompiledFile(compiledName, relativePath, about) {
+    return [
+        `# ${compiledName} — ${relativePath}`,
+        "",
+        UNCOMPILED_COMPILED_PLACEHOLDER,
+        ...(about ? ["", `About: ${about}`] : []),
+        "",
+    ].join("\n");
+}
+function compiledGitignoreEntries(compiledPath) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const zoneEntries = (schema?.zones ?? [])
+        .filter((zone) => zone.kind !== "runtime")
+        .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
+    return [
+        ...zoneEntries,
+        ".claude/",
+        ".codex/",
+        ".agents/",
+        ".cursor/",
+        ".interf/tests/",
+        ".interf/tests/targets/sandboxes/",
+        ".interf/runtime/",
+        ".obsidian/",
+    ];
+}
+function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    if (!schema) {
+        throw new Error(`Missing compiled schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
+    }
+    ensureCompiledZoneTargets(compiledPath, schema);
+    for (const zone of schema.zones) {
+        if (!zone.required || zone.kind !== "file" || zone.id === "raw")
+            continue;
+        const targetPath = join(compiledPath, zone.path);
+        if (existsSync(targetPath))
+            continue;
+        writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
+    }
+}
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
+    assertCompiledName(name, "Compiled");
+    assertCompiledContainer(sourcePath);
+    const compiledPath = compiledCompiledPathForDataset(sourcePath, name);
+    assertWritableTargetDir(compiledPath, "Compiled");
+    mkdirSync(compiledPath, { recursive: true });
+    const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
+    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+    const resolvedAbout = about ?? savedCompiled?.about;
+    const resolvedDatasetPath = savedCompiled
+        ? resolveSourceDatasetPath(sourcePath, savedCompiled)
+        : datasetPath;
+    saveCompiledInterfConfig(compiledPath, {
+        type: "compiled",
         name,
         ...(resolvedAbout ? { about: resolvedAbout } : {}),
         workflow: selectedWorkflow.id,
-        ...(typeof savedWorkspace?.max_attempts === "number"
-            ? { max_attempts: savedWorkspace.max_attempts }
+        ...(typeof savedCompiled?.max_attempts === "number"
+            ? { max_attempts: savedCompiled.max_attempts }
             : {}),
-        ...(typeof savedWorkspace?.max_loops === "number"
-            ? { max_loops: savedWorkspace.max_loops }
+        ...(typeof savedCompiled?.max_loops === "number"
+            ? { max_loops: savedCompiled.max_loops }
             : {}),
-        checks: savedWorkspace?.checks ?? [],
+        checks: savedCompiled?.checks ?? [],
         workflow_origin: {
             selected: selectedWorkflow.id,
             local_draft: false,
         },
         source: {
             path: "./raw",
-            control_path: defaultControlPathForWorkspace(workspacePath),
+            control_path: defaultControlPathForCompiled(compiledPath),
+            dataset_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
         },
     });
-    mkdirSync(join(workspacePath, "raw"), { recursive: true });
-    syncWorkspaceRawSnapshot(workspacePath, sourcePath);
-    writeFileSync(join(workspacePath, ".interfignore"), DEFAULT_INTERFIGNORE);
-    seedWorkspaceWorkflowPackage({
-        workspacePath,
+    mkdirSync(join(compiledPath, "raw"), { recursive: true });
+    syncCompiledRawSnapshot(compiledPath, resolvedDatasetPath);
+    writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
+    seedCompiledWorkflowPackage({
+        compiledPath,
         sourcePath,
         workflowId: selectedWorkflow.id,
     });
-    refreshWorkspaceBootstrapGuidance(workspacePath);
-    writeFileSync(join(workspacePath, "home.md"), renderUncompiledWorkspaceHome(name, about));
-    writeFileSync(join(workspacePath, ".gitignore"), [
-        "raw/",
-        "summaries/",
-        "knowledge/",
-        ".claude/",
-        ".codex/",
-        ".agents/",
-        ".cursor/",
-        ".interf/tests/",
-        ".interf/tests/targets/sandboxes/",
-        ".interf/runtime/",
-        ".obsidian/",
-        "",
-    ].join("\n"));
-    saveState(workspacePath, initWorkspaceState());
-    saveEmptyWorkspaceInventory(workspacePath);
-    refreshWorkspaceArtifacts(workspacePath, { ensureViewSpec: true });
-    writeObsidianDefaults(workspacePath, "workspace");
-    return workspacePath;
+    scaffoldCompiledOutputs(compiledPath, name, about);
+    refreshCompiledBootstrapGuidance(compiledPath);
+    writeFileSync(join(compiledPath, ".gitignore"), [...compiledGitignoreEntries(compiledPath), ""].join("\n"));
+    saveState(compiledPath, initCompiledState());
+    saveEmptyCompiledInventory(compiledPath);
+    refreshCompiledArtifacts(compiledPath, { ensureViewSpec: true });
+    writeObsidianDefaults(compiledPath, "compiled");
+    return compiledPath;
 }
-export function defaultWorkspaceNameForSource(sourcePath) {
+export function defaultCompiledNameForSource(sourcePath) {
     return basename(sourcePath);
 }

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

@@ -1,10 +1,10 @@
 import { type WorkflowDefinition } from "./workflow-definitions.js";
-export declare function writeWorkspaceWorkflowPackage(workspacePath: string, workflow: WorkflowDefinition<string>): void;
+export declare function writeCompiledWorkflowPackage(compiledPath: string, workflow: WorkflowDefinition<string>): void;
 export declare function writeWorkflowPackageToDir(workflowDir: string, workflow: WorkflowDefinition<string>, options?: {
     overwrite?: boolean;
 }): void;
-export declare function seedWorkspaceWorkflowPackage(options: {
-    workspacePath: string;
+export declare function seedCompiledWorkflowPackage(options: {
+    compiledPath: string;
     sourcePath: string;
     workflowId: string;
 }): void;

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

@@ -1,13 +1,13 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { copyWorkflowPackageDirectory, isPortableWorkflowPackage, patchWorkflowPackageMetadata, resolveWorkflowPackageSourcePath, workflowDefinitionPath, } from "./local-workflows.js";
-import { getWorkspaceWorkflow, } from "./workflow-definitions.js";
-import { renderWorkspaceQuerySkill } from "./agent-shells.js";
+import { getCompiledWorkflow, } from "./workflow-definitions.js";
+import { renderCompiledQuerySkill } from "./agent-shells.js";
 import { CHART_APPROXIMATION_NOTES } from "./chart-guidance.js";
-import { writeWorkspaceSchemaFile } from "./workspace-schema.js";
-import { workflowPackagePathForWorkspace } from "./workspace-paths.js";
+import { writeCompiledSchemaFile } from "./compiled-schema.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 function workflowPackagePath(dirPath) {
-    return workflowPackagePathForWorkspace(dirPath);
+    return workflowPackagePathForCompiled(dirPath);
 }
 function mergeWorkflowStagePolicyNotes(stages, baseNotes, nextNotes) {
     const merged = {};
@@ -37,9 +37,9 @@ function writeWorkflowPackageJson(rootPath, workflow, options) {
         return;
     writeFileSync(targetPath, `${JSON.stringify({
         id: workflow.id,
-        type: "workspace",
+        type: "compiled",
         compiler_api: workflow.compilerApi ?? {
-            kind: "workspace",
+            kind: "compiled",
             version: 1,
         },
         label: workflow.label,
@@ -69,7 +69,7 @@ function renderWorkflowReadme(workflow) {
         "## Package",
         "",
         "- `workflow.json` = stage graph, compiler API target, and compile contract mapping",
-        "- `workspace.schema.json` = deterministic workspace output shape",
+        "- `compiled.schema.json` = deterministic compiled-dataset output shape",
         "- `improve/`, `compile/stages/`, and `use/query/` = human-readable authoring docs",
         "- Portable workflow packages are standalone: explicit stages, schema, and docs live together in this folder",
         "- Interf Compiler projects native agent shells from these docs for query use, stage execution, and workflow-improvement loops",
@@ -78,7 +78,7 @@ function renderWorkflowReadme(workflow) {
         "",
         stageLines,
         "",
-        "Interf Compiler runs the workspace-local copy of this package directly from `.interf/workflow/` inside each compiled workspace.",
+        "Interf Compiler runs the local copy of this package directly from `.interf/workflow/` inside each compiled dataset.",
         "",
     ].join("\n");
 }
@@ -90,7 +90,7 @@ function renderDerivedWorkflowReadme(options) {
         "",
         `This workflow package was copied from \`${options.baseWorkflowId}\` and materialized as a standalone package for this dataset job.`,
         "",
-        "Interf Compiler runs the workspace-local copy of this package directly. Keep changes in this folder self-contained instead of relying on runtime inheritance or fallback.",
+        "Interf Compiler runs the local copy of this package directly. Keep changes in this folder self-contained instead of relying on runtime inheritance or fallback.",
         "",
         "## Emphasis",
         "",
@@ -107,13 +107,13 @@ function renderImproveSkill(workflow) {
         `Workflow: ${workflow.id}`,
         "",
         "This file is the editable authoring source for Interf Compiler's generated native workflow-improver shell.",
-        "The improver edits this workspace-local package directly.",
+        "The improver edits this local package directly.",
         "",
         "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 workspace to create a better workflow variation for this dataset.",
-        "4. Keep `workflow.json`, `workspace.schema.json`, and any changed stage docs aligned.",
+        "3. Edit only the local workflow package for this compiled dataset to create a better workflow variation for this dataset.",
+        "4. Keep `workflow.json`, `compiled.schema.json`, and any changed stage docs aligned.",
         "",
         "Guardrails:",
         "- do not edit truth checks, test specs, or raw dataset files",
@@ -125,23 +125,23 @@ function renderImproveSkill(workflow) {
 }
 function renderStageSkill(workflow, stage) {
     const notes = workflow.stagePolicyNotes?.[stage.id] ?? [];
-    const stageSpecificNotes = stage.contractType === "workspace-file-evidence"
+    const stageSpecificNotes = stage.contractType === "compiled-file-evidence"
         ? [
             "Each summary must use JSON frontmatter and include `source`, `source_kind`, `evidence_tier`, `truth_mode`, `state`, and a non-empty `abstract`.",
             "Include a clear abstract block in the body so a human can skim the summary quickly.",
             "Do not skip the abstract just because the overview section is present.",
         ]
-        : stage.contractType === "workspace-knowledge-structure"
+        : stage.contractType === "compiled-knowledge-structure"
             ? [
                 "Treat the knowledge layer as retrieval structure, not final truth.",
                 "Prefer durable entity, claim, and index notes over one giant catch-all file.",
             ]
-            : stage.contractType === "workspace-query-shape"
+            : stage.contractType === "compiled-query-shape"
                 ? [
-                    "Use the workspace focus plus saved truth-check question text to shape `home.md` and retrieval routes.",
+                    "Use the compiled focus plus saved truth-check question text to shape `home.md` and retrieval routes.",
                     "Rewrite `home.md` into a real entrypoint note. Do not leave the scaffold `Not yet compiled.` placeholder in place.",
                     ...CHART_APPROXIMATION_NOTES,
-                    "Do not copy expected answers into the workspace.",
+                    "Do not copy expected answers into the compiled dataset.",
                 ]
                 : [];
     return [
@@ -169,8 +169,8 @@ function renderStageSkill(workflow, stage) {
             : []),
     ].join("\n");
 }
-export function writeWorkspaceWorkflowPackage(workspacePath, workflow) {
-    writeWorkflowPackageToDir(workflowPackagePath(workspacePath), workflow);
+export function writeCompiledWorkflowPackage(compiledPath, workflow) {
+    writeWorkflowPackageToDir(workflowPackagePath(compiledPath), workflow);
 }
 export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
     const overwrite = options.overwrite ?? true;
@@ -181,8 +181,8 @@ export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
         mkdirSync(join(workflowDir, "compile", "stages", stage.skillDir), { recursive: true });
     }
     writeWorkflowPackageJson(workflowDir, workflow, { overwrite });
-    if (overwrite || !existsSync(join(workflowDir, "workspace.schema.json"))) {
-        writeWorkspaceSchemaFile(workflowDir, workflow.stages, `${workflow.label} workspace schema`);
+    if (overwrite || !existsSync(join(workflowDir, "compiled.schema.json"))) {
+        writeCompiledSchemaFile(workflowDir, workflow.stages, `${workflow.label} compiled schema`);
     }
     if (overwrite || !existsSync(join(workflowDir, "README.md"))) {
         writeFileSync(join(workflowDir, "README.md"), renderWorkflowReadme(workflow));
@@ -191,7 +191,7 @@ export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
         writeFileSync(join(workflowDir, "improve", "SKILL.md"), renderImproveSkill(workflow));
     }
     if (overwrite || !existsSync(join(workflowDir, "use", "query", "SKILL.md"))) {
-        writeFileSync(join(workflowDir, "use", "query", "SKILL.md"), renderWorkspaceQuerySkill());
+        writeFileSync(join(workflowDir, "use", "query", "SKILL.md"), renderCompiledQuerySkill());
     }
     for (const stage of workflow.stages) {
         const targetPath = join(workflowDir, "compile", "stages", stage.skillDir, "SKILL.md");
@@ -201,20 +201,20 @@ export function writeWorkflowPackageToDir(workflowDir, workflow, options = {}) {
     }
     writeWorkflowStarterDocs(workflowDir, workflow.starterDocs, { overwrite });
 }
-export function seedWorkspaceWorkflowPackage(options) {
-    const resolvedWorkflow = getWorkspaceWorkflow(options.workflowId, {
+export function seedCompiledWorkflowPackage(options) {
+    const resolvedWorkflow = getCompiledWorkflow(options.workflowId, {
         sourcePath: options.sourcePath,
     });
     const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, resolvedWorkflow.id);
     if (sourceWorkflowPath && isPortableWorkflowPackage(sourceWorkflowPath)) {
         // Portable seed packages can be copied directly because compile runs the
-        // workspace-local package folder without any source-root fallback.
-        copyWorkflowPackageDirectory(sourceWorkflowPath, workflowPackagePath(options.workspacePath));
+        // local package folder without any source-root fallback.
+        copyWorkflowPackageDirectory(sourceWorkflowPath, workflowPackagePath(options.compiledPath));
         return;
     }
     // Legacy or partially-defined seed packages are resolved once and
-    // materialized into a standalone workspace-local package.
-    writeWorkspaceWorkflowPackage(options.workspacePath, resolvedWorkflow);
+    // materialized into a standalone local package.
+    writeCompiledWorkflowPackage(options.compiledPath, resolvedWorkflow);
 }
 export function createLocalWorkflowPackageFromTemplate(options) {
     const sourceWorkflowPath = resolveWorkflowPackageSourcePath(options.sourcePath, options.baseWorkflowId);
@@ -245,7 +245,7 @@ export function createLocalWorkflowPackageFromTemplate(options) {
     }
     // Legacy or inherited base packages are materialized immediately so the new
     // local workflow package is standalone from its first write.
-    const baseWorkflow = getWorkspaceWorkflow(options.baseWorkflowId, {
+    const baseWorkflow = getCompiledWorkflow(options.baseWorkflowId, {
         sourcePath: options.sourcePath,
     });
     const localWorkflow = {

package/dist/lib/interf.d.ts

@@ -1,5 +1,5 @@
-export { INTERF_CONTAINER_NAME, WORKSPACE_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareWorkspaceLayout, readInterfConfig, detectInterf, resolveWorkspace, resolveSourceFolderPath, resolveSourceControlPath, listWorkspacesForSourceFolder, hasSourceFolderInput, assertWorkspaceContainer, assertWritableTargetDir, assertWorkspaceName, } from "./interf-detect.js";
-export type { InterfConfig, ResolvedWorkspace } from "./interf-detect.js";
-export { ensureWorkspaceRawBinding, resolveWorkspaceRawPath, syncWorkspaceRawSnapshot, } from "./workspace-raw.js";
-export { refreshWorkspaceBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createWorkspace, defaultWorkspaceNameForSource, } from "./interf-scaffold.js";
+export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareCompiledLayout, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
+export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
+export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";

package/dist/lib/interf.js

@@ -1,4 +1,4 @@
-export { INTERF_CONTAINER_NAME, WORKSPACE_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareWorkspaceLayout, readInterfConfig, detectInterf, resolveWorkspace, resolveSourceFolderPath, resolveSourceControlPath, listWorkspacesForSourceFolder, hasSourceFolderInput, assertWorkspaceContainer, assertWritableTargetDir, assertWorkspaceName, } from "./interf-detect.js";
-export { ensureWorkspaceRawBinding, resolveWorkspaceRawPath, syncWorkspaceRawSnapshot, } from "./workspace-raw.js";
-export { refreshWorkspaceBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
-export { createWorkspace, defaultWorkspaceNameForSource, } from "./interf-scaffold.js";
+export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, prepareCompiledLayout, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
+export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
+export { createCompiled, defaultCompiledNameForSource, } from "./interf-scaffold.js";

package/dist/lib/local-workflows.d.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowStageZoneAccessSchema, type WorkflowWorkspaceSchema } from "./schema.js";
+import { WorkflowCompilerApiSchema, RuntimeContractTypeSchema, RuntimeStageAcceptanceSchema, WorkflowStageZoneAccessSchema, type WorkflowCompiledSchema } from "./schema.js";
 export interface LocalWorkflowStarterDoc {
     relativePath: string;
     content: string;
@@ -16,18 +16,18 @@ export interface LocalWorkflowStageDefinition {
 }
 export interface LocalWorkflowDefinition {
     id: string;
-    type: "workspace";
+    type: "compiled";
     compiler_api?: z.infer<typeof WorkflowCompilerApiSchema>;
     label: string;
     hint: string;
     extends?: string;
     stages?: LocalWorkflowStageDefinition[];
     stage_policy_notes?: Record<string, string[]>;
-    workspace_schema: WorkflowWorkspaceSchema;
+    compiled_schema: WorkflowCompiledSchema;
     starter_docs: LocalWorkflowStarterDoc[];
     directoryPath: string;
     workflowPath: string;
-    workspaceSchemaPath: string;
+    compiledSchemaPath: string;
 }
 export declare function workflowDefinitionPath(sourcePath: string, id: string): string;
 export declare function loadWorkflowDefinitionFromDir(dirPath: string): LocalWorkflowDefinition | null;