@interf/compiler 0.4.1 → 0.5.1

package/dist/lib/interf-detect.js

@@ -1,98 +1,98 @@
 import { existsSync, readdirSync, statSync, } from "node:fs";
 import { join, resolve } from "node:path";
 import { warnInterf } from "./logger.js";
-import { readJsonFileWithSchema } from "./parse.js";
-import { resolveSourceControlPathForWorkspace, workspaceInterfConfigPath, } from "./workspace-paths.js";
-import { normalizeLegacyWorkspaceLayout, workspaceNeedsLegacyLayoutNormalization, } from "./workspace-layout.js";
+import { readJsonFileUnchecked } from "./parse.js";
+import { compiledCompiledPathForDataset, projectInterfRoot, } from "./project-paths.js";
+import { resolveSourceControlPathForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
 import { InterfConfigSchema, } from "./schema.js";
+import { assertPathWithinRoot } from "./util.js";
 export const INTERF_CONTAINER_NAME = "interf";
-export const WORKSPACE_CONTAINER_NAME = "workspaces";
 export const WORKFLOW_CONTAINER_NAME = "workflows";
 export const TEST_CONTAINER_NAME = "tests";
 export const INTERF_CONFIG_FILE = "interf.json";
 export const WORKFLOW_PACKAGE_DIR = "workflow";
-export function prepareWorkspaceLayout(dirPath) {
-    if (!workspaceNeedsLegacyLayoutNormalization(dirPath)) {
-        return false;
-    }
-    return normalizeLegacyWorkspaceLayout(dirPath);
-}
 export function readInterfConfig(dirPath) {
-    const configPath = workspaceInterfConfigPath(dirPath);
+    const configPath = compiledInterfConfigPath(dirPath);
     if (!existsSync(configPath))
         return null;
-    return readJsonFileWithSchema(configPath, "Interf config", InterfConfigSchema);
+    const raw = readJsonFileUnchecked(configPath, "Interf config");
+    if (raw === null)
+        return null;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    if (raw.type !== "compiled") {
+        return null;
+    }
+    const parsed = InterfConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+        warnInterf(`Warning: failed to validate Interf config at ${configPath}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+        return null;
+    }
+    return parsed.data;
 }
 export function hasSourceFolderInput(config) {
     return typeof config?.source?.path === "string" && config.source.path.length > 0;
 }
 export function detectInterf(cwd) {
-    prepareWorkspaceLayout(cwd);
     const config = readInterfConfig(cwd);
     if (config)
         return { path: cwd, config };
     return null;
 }
-export function resolveWorkspace(cwd) {
+export function resolveCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
         return null;
     return {
         sourcePath: resolveSourceControlPath(detected.path),
-        workspacePath: detected.path,
+        compiledPath: detected.path,
         config: detected.config,
     };
 }
-export function resolveSourceFolderPath(workspacePath, config = null) {
-    prepareWorkspaceLayout(workspacePath);
-    const resolvedConfig = config ?? readInterfConfig(workspacePath);
+export function resolveSourceFolderPath(compiledPath, config = null) {
+    const resolvedConfig = config ?? readInterfConfig(compiledPath);
     if (hasSourceFolderInput(resolvedConfig)) {
-        return resolve(workspacePath, resolvedConfig.source.path);
+        return assertPathWithinRoot(compiledPath, resolve(compiledPath, resolvedConfig.source.path), "Compiled raw source path");
     }
-    return resolve(workspacePath, "raw");
+    return resolve(compiledPath, "raw");
+}
+export function resolveSourceControlPath(compiledPath) {
+    return resolveSourceControlPathForCompiled(compiledPath);
 }
-export function resolveSourceControlPath(workspacePath) {
-    prepareWorkspaceLayout(workspacePath);
-    const config = readInterfConfig(workspacePath);
-    if (typeof config?.source?.control_path === "string" && config.source.control_path.length > 0) {
-        return resolve(workspacePath, config.source.control_path);
+export function resolveSourceInputPath(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (typeof config?.source?.dataset_path === "string" && config.source.dataset_path.length > 0) {
+        const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+        return assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Dataset source path");
     }
-    return resolveSourceControlPathForWorkspace(workspacePath);
+    throw new Error(`Compiled dataset is missing source.dataset_path in ${compiledInterfConfigPath(compiledPath)}.`);
 }
-function listWorkspaceEntries(containerPath) {
-    if (!existsSync(containerPath))
+export function listCompiledDatasetsForSourceFolder(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
+    if (!existsSync(interfRoot))
         return [];
     try {
-        if (!statSync(containerPath).isDirectory())
+        if (!statSync(interfRoot).isDirectory())
             return [];
     }
     catch (error) {
-        warnInterf(`Warning: failed to inspect Interf container at ${containerPath}: ${error instanceof Error ? error.message : String(error)}`);
+        warnInterf(`Warning: failed to inspect Interf container at ${interfRoot}: ${error instanceof Error ? error.message : String(error)}`);
         return [];
     }
-    return readdirSync(containerPath)
-        .map((entry) => join(containerPath, entry))
-        .filter((entryPath) => {
-        try {
-            return statSync(entryPath).isDirectory();
-        }
-        catch (error) {
-            warnInterf(`Warning: failed to inspect workspace candidate at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
-            return false;
-        }
-    })
-        .map((entryPath) => {
-        prepareWorkspaceLayout(entryPath);
-        const config = readInterfConfig(entryPath);
-        return config ? { path: entryPath, config } : null;
+    return readdirSync(interfRoot)
+        .filter((entry) => !entry.startsWith(".") &&
+        entry !== WORKFLOW_CONTAINER_NAME &&
+        entry !== TEST_CONTAINER_NAME)
+        .map((entry) => compiledCompiledPathForDataset(sourcePath, entry))
+        .filter((compiledPath) => existsSync(compiledPath))
+        .map((compiledPath) => {
+        const config = readInterfConfig(compiledPath);
+        return config ? { path: compiledPath, config } : null;
     })
         .filter((value) => value !== null);
 }
-export function listWorkspacesForSourceFolder(sourcePath) {
-    return listWorkspaceEntries(join(sourcePath, INTERF_CONTAINER_NAME, WORKSPACE_CONTAINER_NAME));
-}
-export function assertWorkspaceContainer(sourcePath) {
-    const interfRoot = join(sourcePath, INTERF_CONTAINER_NAME);
+export function assertCompiledContainer(sourcePath) {
+    const interfRoot = projectInterfRoot(sourcePath);
     if (existsSync(interfRoot)) {
         const stat = statSync(interfRoot);
         if (!stat.isDirectory()) {
@@ -102,9 +102,7 @@ export function assertWorkspaceContainer(sourcePath) {
             if (entry.startsWith("."))
                 return false;
             const entryPath = join(interfRoot, entry);
-            if (entry === WORKSPACE_CONTAINER_NAME ||
-                entry === WORKFLOW_CONTAINER_NAME ||
-                entry === TEST_CONTAINER_NAME) {
+            if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME) {
                 try {
                     return !statSync(entryPath).isDirectory();
                 }
@@ -113,13 +111,21 @@ export function assertWorkspaceContainer(sourcePath) {
                     return true;
                 }
             }
-            return true;
+            try {
+                if (!statSync(entryPath).isDirectory())
+                    return true;
+            }
+            catch (error) {
+                warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
+                return true;
+            }
+            return false;
         });
         if (unexpectedRootEntries.length > 0) {
             throw new Error(`Interf container contains unexpected entries: ${interfRoot}`);
         }
     }
-    const containerPath = join(interfRoot, WORKSPACE_CONTAINER_NAME);
+    const containerPath = interfRoot;
     if (!existsSync(containerPath)) {
         return containerPath;
     }
@@ -130,6 +136,8 @@ export function assertWorkspaceContainer(sourcePath) {
     const unexpectedEntries = readdirSync(containerPath).filter((entry) => {
         if (entry.startsWith("."))
             return false;
+        if (entry === WORKFLOW_CONTAINER_NAME || entry === TEST_CONTAINER_NAME)
+            return false;
         const entryPath = join(containerPath, entry);
         try {
             if (!statSync(entryPath).isDirectory())
@@ -139,11 +147,14 @@ export function assertWorkspaceContainer(sourcePath) {
             warnInterf(`Warning: failed to inspect Interf entry at ${entryPath}: ${error instanceof Error ? error.message : String(error)}`);
             return true;
         }
-        prepareWorkspaceLayout(entryPath);
-        return !readInterfConfig(entryPath);
+        const compiledPath = compiledCompiledPathForDataset(sourcePath, entry);
+        if (!existsSync(compiledPath)) {
+            return false;
+        }
+        return !readInterfConfig(compiledPath);
     });
     if (unexpectedEntries.length > 0) {
-        throw new Error(`Interf container contains invalid workspace entries: ${containerPath}`);
+        throw new Error(`Interf container contains invalid dataset entries: ${containerPath}`);
     }
     return containerPath;
 }
@@ -158,7 +169,7 @@ export function assertWritableTargetDir(dirPath, label) {
         throw new Error(`${label} target already exists and is not empty: ${dirPath}`);
     }
 }
-export function assertWorkspaceName(name, label) {
+export function assertCompiledName(name, label) {
     if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
         throw new Error(`${label} name must be a safe slug with lowercase letters, numbers, and dashes only: ${name}`);
     }

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

@@ -1,2 +1,2 @@
-export declare function createWorkspace(name: string, sourcePath: string, workflowId?: string, about?: string): string;
-export declare function defaultWorkspaceNameForSource(sourcePath: string): string;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function defaultCompiledNameForSource(sourcePath: string): string;

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, 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, 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;