@interf/compiler 0.4.1 → 0.5.1

package/dist/lib/workflow-stage-runner.d.ts

@@ -9,7 +9,7 @@ interface WorkflowStageShape<TContractType extends RuntimeContractType> {
 }
 interface ExecuteValidatedStageOptions<TContractType extends RuntimeContractType> {
     executor: WorkflowExecutor;
-    workspacePath: string;
+    compiledPath: string;
     executionPath?: string;
     targetName: string;
     workflow: string;

package/dist/lib/workflow-stage-runner.js

@@ -17,9 +17,9 @@ export async function executeValidatedStage(options) {
         : undefined;
     const code = await runExecutorStage({
         executor: options.executor,
-        workspacePath: options.workspacePath,
+        compiledPath: options.compiledPath,
         executionPath: options.executionPath,
-        workspaceName: options.targetName,
+        compiledName: options.targetName,
         workflow: options.workflow,
         workflowSourcePath: options.workflowSourcePath,
         stage: options.stageDefinition.id,
@@ -42,9 +42,9 @@ export async function executeValidatedSummarizeStage(options) {
         : undefined;
     const code = await runExecutorSummarizeStage({
         executor: options.executor,
-        workspacePath: options.workspacePath,
+        compiledPath: options.compiledPath,
         executionPath: options.executionPath,
-        workspaceName: options.targetName,
+        compiledName: options.targetName,
         workflow: options.workflow,
         workflowSourcePath: options.workflowSourcePath,
         stage: options.stageDefinition.id,
@@ -64,7 +64,7 @@ function finalizeValidatedStage(options, code) {
         options.syncWrites?.();
         options.reconcile?.();
         options.refreshArtifacts?.();
-        return validateStageOutcome(options.workspacePath, options.validate());
+        return validateStageOutcome(options.compiledPath, options.validate());
     };
     if (code !== 0) {
         let completionSatisfied = false;
@@ -79,7 +79,7 @@ function finalizeValidatedStage(options, code) {
         if (completionSatisfied) {
             const validation = refreshAndValidate();
             if (validation.ok) {
-                markRuntimeRunSucceededAfterValidation(options.workspacePath, validation.summary);
+                markRuntimeRunSucceededAfterValidation(options.compiledPath, validation.summary);
                 return {
                     ok: true,
                     code: 0,
@@ -87,7 +87,7 @@ function finalizeValidatedStage(options, code) {
                 };
             }
             reportValidationFailure(options.reporter, validation.summary);
-            markRuntimeRunFailedAfterValidation(options.workspacePath, validation.summary);
+            markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
             return {
                 ok: false,
                 code,
@@ -99,7 +99,7 @@ function finalizeValidatedStage(options, code) {
     const validation = refreshAndValidate();
     if (!validation.ok) {
         reportValidationFailure(options.reporter, validation.summary);
-        markRuntimeRunFailedAfterValidation(options.workspacePath, validation.summary);
+        markRuntimeRunFailedAfterValidation(options.compiledPath, validation.summary);
     }
     return {
         ok: validation.ok,

package/dist/lib/workflows.d.ts

@@ -1,15 +1,15 @@
 import { type InterfConfig } from "./interf.js";
 export type { WorkflowReporter, WorkflowStageResult, LocalSkillContractExtension } from "./workflow-helpers.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
-export type WorkspaceCheck = "summarize" | "structure" | "compile";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
+export type CompiledCheck = "compiled" | "stage";
 export interface DetectedInterfTarget {
     path: string;
-    kind: "workspace";
-    engineType: "workspace";
+    kind: "compiled";
+    engineType: "compiled";
     config: InterfConfig;
 }
-export declare function detectWorkspace(cwd: string): DetectedInterfTarget | null;
-export declare function createWorkspace(name: string, sourcePath: string, workflowId?: string, about?: string): string;
-export declare function verifyWorkspaceCheck(check: WorkspaceCheck, workspacePath: string): import("./validate-workspace.js").WorkspaceSummarizeValidation | import("./validate-workspace.js").WorkspaceCompileValidation | import("./validate-workspace.js").WorkspaceStructureValidation;
-export { runWorkspaceSummarize, runWorkspaceCompile, compileWorkspace, resolveWorkspaceContext, workspaceExecutionStages, } from "./workspace-compile.js";
-export type { WorkspaceSummarizeResult, WorkspaceCompileResult, WorkspaceStageExecutionDefinition, StageShellRetentionMode, } from "./workspace-compile.js";
+export declare function detectCompiled(cwd: string): DetectedInterfTarget | null;
+export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function verifyCompiledCheck(check: CompiledCheck, compiledPath: string): import("./validate-compiled.js").CompiledWorkflowValidation;
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";
+export type { CompiledSummarizeResult, CompiledCompileResult, CompiledStageExecutionDefinition, StageShellRetentionMode, } from "./compiled-compile.js";

package/dist/lib/workflows.js

@@ -1,33 +1,31 @@
-import { createWorkspace as createWorkspaceScaffold, } from "./interf.js";
+import { createCompiled as createCompiledScaffold, } from "./interf.js";
 import { detectInterf } from "./interf.js";
-import { validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "./validate.js";
-export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, bundledSkillForContractType, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
-export function detectWorkspace(cwd) {
+import { validateCompiledCompile, } from "./validate.js";
+export { workflowQueryDirectory, workflowImproveDirectory, workflowCompileStageDirectory, emptyLocalSkillContractExtension, buildLocalSkillContractExtension, buildLocalSkillContractExtensionRelativeTo, mergeLocalSkillContractExtensions, buildStageInstructions, reportLine, reportBlankLine, reportValidationFailure, resolveStageAcceptance, validateStageOutcome, } from "./workflow-helpers.js";
+export function detectCompiled(cwd) {
     const detected = detectInterf(cwd);
     if (!detected)
         return null;
     return {
         path: detected.path,
-        kind: "workspace",
-        engineType: "workspace",
+        kind: "compiled",
+        engineType: "compiled",
         config: detected.config,
     };
 }
-export function createWorkspace(name, sourcePath, workflowId = "interf", about) {
-    return createWorkspaceScaffold(name, sourcePath, workflowId, about);
+export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath = sourcePath) {
+    return createCompiledScaffold(name, sourcePath, workflowId, about, datasetPath);
 }
-export function verifyWorkspaceCheck(check, workspacePath) {
+export function verifyCompiledCheck(check, compiledPath) {
     switch (check) {
-        case "summarize":
-            return validateWorkspaceSummarize(workspacePath);
-        case "structure":
-            return validateWorkspaceStructure(workspacePath);
-        case "compile":
-            return validateWorkspaceCompile(workspacePath);
+        case "compiled":
+            return validateCompiledCompile(compiledPath);
+        case "stage":
+            return validateCompiledCompile(compiledPath);
         default: {
             const exhaustiveCheck = check;
-            throw new Error(`Unknown workspace check: ${exhaustiveCheck}`);
+            throw new Error(`Unknown compiled check: ${exhaustiveCheck}`);
         }
     }
 }
-export { runWorkspaceSummarize, runWorkspaceCompile, compileWorkspace, resolveWorkspaceContext, workspaceExecutionStages, } from "./workspace-compile.js";
+export { runCompiledSummarize, runCompiledCompile, compileCompiled, resolveCompiledContext, compiledExecutionStages, } from "./compiled-compile.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.4.1",
-  "description": "Interf Compiler is a local runtime for data-processing workflows that turn datasets into compiled workspaces for local agents.",
+  "version": "0.5.1",
+  "description": "Interf Compiler is a local runtime for data-processing workflows that prepare datasets for accurate local agent use.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -27,22 +27,23 @@
     "test:e2e:claude": "npm run test:acceptance-live -- --agent claude-code",
     "test:e2e:codex": "npm run test:acceptance-live -- --agent codex",
     "test:e2e:quick": "npm run test:e2e:quick:matrix",
-    "test:e2e:quick:claude": "npm run test:acceptance-cache:refresh:claude && npm run test:acceptance-quick:create-workspace -- --agent claude-code --cache-root .interf-test-cache/claude-code && npm run test:acceptance-quick:query-workspace -- --agent claude-code --cache-root .interf-test-cache/claude-code && npm run test:acceptance-quick:self-improving -- --agent claude-code",
-    "test:e2e:quick:codex": "npm run test:acceptance-cache:refresh:codex && npm run test:acceptance-quick:create-workspace -- --agent codex --cache-root .interf-test-cache/codex && npm run test:acceptance-quick:query-workspace -- --agent codex --cache-root .interf-test-cache/codex && npm run test:acceptance-quick:self-improving -- --agent codex",
+    "test:e2e:quick:agent": "node scripts/run-quick-e2e.mjs",
+    "test:e2e:quick:claude": "npm run test:e2e:quick:agent -- --agent claude-code",
+    "test:e2e:quick:codex": "npm run test:e2e:quick:agent -- --agent codex",
     "test:e2e:quick:matrix": "npm run test:e2e:quick:claude && npm run test:e2e:quick:codex",
     "test:internal:cbre:fast": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json",
-    "test:internal:cbre:fast:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json --keep-workspaces",
+    "test:internal:cbre:fast:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-sanity.json --keep-project-clones",
     "test:internal:cbre:max": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json",
-    "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-workspaces",
+    "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-project-clones",
     "test:full": "npm test && npm run test:e2e:quick:matrix",
     "test:release:matrix": "npm run test:internal:cbre:max",
-    "test:release": "npm test && npm run test:e2e:claude && npm run test:e2e:codex && npm run test:release:matrix",
+    "test:release": "npm test && npm run test:acceptance-live -- --agent claude-code --with-test && npm run test:acceptance-live -- --agent codex --with-test",
     "test:acceptance-live": "npm run build && node scripts/acceptance-live.mjs",
-    "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude",
-    "test:acceptance-cache:refresh:claude": "npm run build && node scripts/acceptance-live.mjs --agent claude-code --output-root .interf-test-cache/claude-code",
-    "test:acceptance-cache:refresh:codex": "npm run build && node scripts/acceptance-live.mjs --agent codex --output-root .interf-test-cache/codex",
-    "test:acceptance-quick:create-workspace": "npm run build && node scripts/acceptance-targeted.mjs create-workspace",
-    "test:acceptance-quick:query-workspace": "npm run build && node scripts/acceptance-targeted.mjs workspace-query",
+    "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude && npm run test:acceptance-cache:refresh:codex",
+    "test:acceptance-cache:refresh:claude": "node scripts/acceptance-cache-refresh.mjs --agent claude-code",
+    "test:acceptance-cache:refresh:codex": "node scripts/acceptance-cache-refresh.mjs --agent codex",
+    "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance-targeted.mjs create-compiled",
+    "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance-targeted.mjs compiled-query",
     "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance-targeted.mjs self-improving-compile",
     "prepublishOnly": "node scripts/prepublish-gate.mjs"
   },

package/dist/commands/workspace-flow.d.ts

@@ -1,23 +0,0 @@
-import type { SourceWorkspaceConfig } from "../lib/schema.js";
-import { type StageShellRetentionMode } from "../lib/workflows.js";
-import type { WorkflowExecutor } from "../lib/executors.js";
-import type { WorkspaceCompileResult } from "../lib/workflows.js";
-export interface SavedWorkspaceEntry {
-    config: SourceWorkspaceConfig;
-    path: string | null;
-    localDraft: boolean;
-}
-export declare function listSavedWorkspaceEntries(sourcePath: string): SavedWorkspaceEntry[];
-export declare function findBuiltWorkspacePath(sourcePath: string, workspaceName: string): string | null;
-export declare function findSavedWorkspaceConfig(sourcePath: string, workspaceName: string): SourceWorkspaceConfig | null;
-export declare function chooseWorkspaceConfigToBuild(options: {
-    sourcePath: string;
-    selectMessage: string;
-}): Promise<SourceWorkspaceConfig | null | undefined>;
-export declare function createWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
-export declare function ensureWorkspaceFromConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig): string;
-export declare function compileWorkspaceWithReporter(executor: WorkflowExecutor, workspacePath: string, options?: {
-    heading?: string;
-    successMessage?: string;
-    preserveStageShells?: StageShellRetentionMode;
-}): Promise<WorkspaceCompileResult>;

package/dist/commands/workspace-flow.js

@@ -1,109 +0,0 @@
-import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { listWorkspacesForSourceFolder } from "../lib/interf.js";
-import { addWorkspace } from "../lib/registry.js";
-import { listSourceWorkspaceConfigs, loadWorkspaceControlConfig, loadSourceFolderConfig, sourceWorkspaceConfigFromInterfConfig, syncWorkspaceInterfConfigFromSourceWorkspaceConfig, } from "../lib/source-config.js";
-import { compileWorkspace, createWorkspace, } from "../lib/workflows.js";
-import { formatWorkflowExecutionProfile } from "../lib/execution-profile.js";
-function formatSavedWorkspaceHint(entry) {
-    const config = entry.config;
-    const checkCount = config.checks.length;
-    const workflowHint = `workflow ${config.workflow ?? "interf"}${entry.localDraft ? " (local draft)" : ""}`;
-    if (config.about)
-        return `${config.about} · ${workflowHint}`;
-    if (checkCount === 0)
-        return "No saved truth checks yet";
-    return `${checkCount} saved truth check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
-}
-export function listSavedWorkspaceEntries(sourcePath) {
-    const entries = new Map();
-    for (const builtWorkspace of listWorkspacesForSourceFolder(sourcePath)) {
-        const workspaceConfig = loadWorkspaceControlConfig(builtWorkspace.path)
-            ?? sourceWorkspaceConfigFromInterfConfig(builtWorkspace.config);
-        entries.set(builtWorkspace.config.name, {
-            config: workspaceConfig,
-            path: builtWorkspace.path,
-            localDraft: builtWorkspace.config.workflow_origin?.local_draft === true,
-        });
-    }
-    for (const config of listSourceWorkspaceConfigs(loadSourceFolderConfig(sourcePath))) {
-        if (entries.has(config.name))
-            continue;
-        entries.set(config.name, {
-            config,
-            path: null,
-            localDraft: false,
-        });
-    }
-    return Array.from(entries.values()).sort((left, right) => left.config.name.localeCompare(right.config.name));
-}
-export function findBuiltWorkspacePath(sourcePath, workspaceName) {
-    return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.path ?? null;
-}
-export function findSavedWorkspaceConfig(sourcePath, workspaceName) {
-    return listSavedWorkspaceEntries(sourcePath).find((entry) => entry.config.name === workspaceName)?.config ?? null;
-}
-export async function chooseWorkspaceConfigToBuild(options) {
-    const savedEntries = listSavedWorkspaceEntries(options.sourcePath);
-    if (savedEntries.length === 0) {
-        return null;
-    }
-    if (savedEntries.length === 1) {
-        return savedEntries[0]?.config ?? null;
-    }
-    const selected = await p.select({
-        message: options.selectMessage,
-        options: savedEntries.map((entry) => ({
-            value: entry.config.name,
-            label: entry.config.name,
-            hint: [
-                formatSavedWorkspaceHint(entry),
-                entry.path ? "built" : "not built yet",
-            ].join(" · "),
-        })),
-    });
-    if (p.isCancel(selected))
-        return undefined;
-    return savedEntries.find((entry) => entry.config.name === selected)?.config ?? null;
-}
-export function createWorkspaceFromConfig(sourcePath, workspaceConfig) {
-    const workflowId = workspaceConfig.workflow ?? "interf";
-    const workspacePath = createWorkspace(workspaceConfig.name, sourcePath, workflowId, workspaceConfig.about);
-    syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath, workspaceConfig);
-    addWorkspace(workspaceConfig.name, workspacePath, workflowId);
-    return workspacePath;
-}
-export function ensureWorkspaceFromConfig(sourcePath, workspaceConfig) {
-    const existingPath = findBuiltWorkspacePath(sourcePath, workspaceConfig.name);
-    if (existingPath) {
-        syncWorkspaceInterfConfigFromSourceWorkspaceConfig(existingPath, workspaceConfig);
-        addWorkspace(workspaceConfig.name, existingPath, workspaceConfig.workflow ?? "interf");
-        return existingPath;
-    }
-    return createWorkspaceFromConfig(sourcePath, workspaceConfig);
-}
-export async function compileWorkspaceWithReporter(executor, workspacePath, options = {}) {
-    console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building compiled workspace..."}`));
-    const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
-    if (profileLabel) {
-        console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
-    }
-    console.log();
-    const reporter = {
-        line: (message) => console.log(chalk.dim(`  ${message}`)),
-        blankLine: () => console.log(),
-    };
-    const result = await compileWorkspace({
-        executor,
-        workspacePath,
-        reporter,
-        preserveStageShells: options.preserveStageShells,
-    });
-    if (!result.ok) {
-        return result;
-    }
-    console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled workspace ready."}`));
-    return result;
-}

package/dist/lib/registry.d.ts

@@ -1,16 +0,0 @@
-export interface WorkspaceEntry {
-    name: string;
-    path: string;
-    workflow: string;
-    created: string;
-}
-export interface Registry {
-    version: number;
-    workspaces: WorkspaceEntry[];
-}
-export declare function loadRegistry(): Registry;
-export declare function saveRegistry(registry: Registry): void;
-export declare function listWorkspaceEntries(registry?: Registry): WorkspaceEntry[];
-export declare function addWorkspace(name: string, path: string, workflow: string): void;
-export declare function findWorkspaceByName(name: string): WorkspaceEntry[];
-export declare function findInterf(name: string): WorkspaceEntry | undefined;

package/dist/lib/registry.js

@@ -1,65 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { INTERF_HOME, REGISTRY_PATH } from "./config.js";
-import { readJsonFileUnchecked } from "./parse.js";
-function normalizeWorkspaceEntry(value) {
-    const name = String(value.name ?? "");
-    const path = String(value.path ?? "");
-    if (name.length === 0 || path.length === 0)
-        return null;
-    return {
-        name,
-        path,
-        workflow: String(value.workflow ?? "interf"),
-        created: String(value.created ?? new Date().toISOString()),
-    };
-}
-export function loadRegistry() {
-    const empty = { version: 7, workspaces: [] };
-    if (!existsSync(REGISTRY_PATH)) {
-        return empty;
-    }
-    const raw = readJsonFileUnchecked(REGISTRY_PATH, "Interf registry");
-    if (!raw)
-        return empty;
-    const seen = new Set();
-    const workspaces = [];
-    const rawWorkspaces = Array.isArray(raw.workspaces) ? raw.workspaces : [];
-    for (const value of rawWorkspaces) {
-        if (!value || typeof value !== "object")
-            continue;
-        const entry = normalizeWorkspaceEntry(value);
-        if (!entry || seen.has(entry.path))
-            continue;
-        seen.add(entry.path);
-        workspaces.push(entry);
-    }
-    return {
-        version: 7,
-        workspaces,
-    };
-}
-export function saveRegistry(registry) {
-    mkdirSync(INTERF_HOME, { recursive: true });
-    writeFileSync(REGISTRY_PATH, JSON.stringify({ version: 7, workspaces: registry.workspaces }, null, 2) + "\n");
-}
-export function listWorkspaceEntries(registry = loadRegistry()) {
-    return [...registry.workspaces].sort((left, right) => left.name.localeCompare(right.name) || left.path.localeCompare(right.path));
-}
-export function addWorkspace(name, path, workflow) {
-    const reg = loadRegistry();
-    reg.workspaces = reg.workspaces.filter((entry) => entry.path !== path);
-    reg.workspaces.push({
-        name,
-        path,
-        workflow,
-        created: new Date().toISOString(),
-    });
-    saveRegistry(reg);
-}
-export function findWorkspaceByName(name) {
-    return listWorkspaceEntries().filter((workspace) => workspace.name === name);
-}
-export function findInterf(name) {
-    const matches = listWorkspaceEntries().filter((workspace) => workspace.name === name);
-    return matches.length === 1 ? matches[0] : undefined;
-}

package/dist/lib/validate-workspace.d.ts

@@ -1,121 +0,0 @@
-export interface WorkspaceValidationSummary {
-    config_present: boolean;
-    config_valid: boolean;
-    config_type_match: boolean;
-    summary_frontmatter_valid: boolean;
-    abstracts_valid: boolean;
-    invalid_frontmatter: number;
-    short_abstracts: number;
-    broken_links: number;
-}
-export interface WorkspaceSummarizeValidation {
-    ok: boolean;
-    required: boolean;
-    summary: string;
-    counts: {
-        source_total: number;
-        source_covered: number;
-        summarized: number;
-        to_summarize: number;
-        invalid_frontmatter: number;
-        short_abstracts: number;
-        inventory_total: number;
-    };
-    checks: {
-        config_present: boolean;
-        config_valid: boolean;
-        config_type_match: boolean;
-        summaries_present: boolean;
-        state_present: boolean;
-        state_valid: boolean;
-        inventory_present: boolean;
-        inventory_valid: boolean;
-        inventory_complete: boolean;
-        inventory_matches_summaries: boolean;
-        state_covers_summaries: boolean;
-        full_source_coverage: boolean;
-        summary_frontmatter_valid: boolean;
-        abstracts_valid: boolean;
-    };
-    errors: string[];
-}
-export interface WorkspaceCompileValidation {
-    ok: boolean;
-    required: boolean;
-    summary: string;
-    counts: {
-        source_total: number;
-        summarized: number;
-        structured: number;
-        shaped: number;
-        compiled: number;
-        inventory_total: number;
-        frontmatter_scanned: number;
-        abstracts_read: number;
-        full_reads: number;
-        entity_files: number;
-        claim_files: number;
-        index_files: number;
-        outputs: number;
-    };
-    checks: {
-        config_present: boolean;
-        config_valid: boolean;
-        config_type_match: boolean;
-        summarize_complete: boolean;
-        structure_complete: boolean;
-        state_present: boolean;
-        state_valid: boolean;
-        inventory_present: boolean;
-        inventory_valid: boolean;
-        inventory_complete: boolean;
-        inventory_matches_summaries: boolean;
-        frontmatter_inventory_complete: boolean;
-        abstracts_cover_summaries: boolean;
-        shaped_complete: boolean;
-        compiled_complete: boolean;
-        outputs_present: boolean;
-        home_present: boolean;
-        links_valid: boolean;
-    };
-    errors: string[];
-}
-export interface WorkspaceStructureValidation {
-    ok: boolean;
-    required: boolean;
-    summary: string;
-    counts: {
-        source_total: number;
-        summarized: number;
-        structured: number;
-        inventory_total: number;
-        frontmatter_scanned: number;
-        abstracts_read: number;
-        entity_files: number;
-        claim_files: number;
-        index_files: number;
-        outputs: number;
-    };
-    checks: {
-        config_present: boolean;
-        config_valid: boolean;
-        config_type_match: boolean;
-        summarize_complete: boolean;
-        state_present: boolean;
-        state_valid: boolean;
-        inventory_present: boolean;
-        inventory_valid: boolean;
-        inventory_complete: boolean;
-        inventory_matches_summaries: boolean;
-        frontmatter_inventory_complete: boolean;
-        abstracts_cover_summaries: boolean;
-        structured_complete: boolean;
-        outputs_present: boolean;
-        links_valid: boolean;
-    };
-    errors: string[];
-}
-export declare function validateWorkspace(dirPath: string): WorkspaceValidationSummary;
-export declare function validateWorkspaceSummarize(dirPath: string): WorkspaceSummarizeValidation;
-export declare function validateWorkspaceCompile(dirPath: string): WorkspaceCompileValidation;
-export declare function validateWorkspaceStructure(dirPath: string): WorkspaceStructureValidation;