@interf/compiler 0.4.1 → 0.5.0

package/dist/lib/validate-compiled.js

@@ -0,0 +1,236 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { discoverSourceFiles } from "./discovery.js";
+import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { resolveSourceFolderPath } from "./interf.js";
+import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { readCompiledConfig } from "./validate.js";
+import { loadState } from "./state.js";
+import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
+import { getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
+import { listFilesRecursive } from "./filesystem.js";
+function countZoneArtifacts(compiledPath, zonePath, kind) {
+    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
+    if (!existsSync(absolutePath))
+        return 0;
+    if (kind === "file")
+        return 1;
+    return listFilesRecursive(absolutePath).length;
+}
+function readWorkflowContext(dirPath) {
+    const config = readCompiledConfig(dirPath);
+    const workflowId = config.valid ? resolveCompiledWorkflowFromConfig(config.value) : null;
+    let workflow = null;
+    if (workflowId) {
+        try {
+            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+        }
+        catch {
+            workflow = null;
+        }
+    }
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const state = loadState(dirPath);
+    const sourceTotal = config.valid
+        ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
+        : 0;
+    return {
+        config,
+        workflow,
+        schema,
+        state,
+        sourceTotal,
+        workflowId,
+    };
+}
+function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
+    return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
+}
+function zoneWriteCount(compiledPath, schema, stage) {
+    const zoneCounts = {};
+    let total = 0;
+    for (const zoneId of stage.writes) {
+        const zone = findCompiledSchemaZone(schema, zoneId);
+        if (!zone)
+            continue;
+        const count = countZoneArtifacts(compiledPath, zone.path, zone.kind);
+        zoneCounts[zoneId] = count;
+        total += count;
+    }
+    return { total, zoneCounts };
+}
+function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
+    const merged = {
+        source_total: sourceTotal,
+        ...zoneCounts,
+    };
+    const stageCounts = stageRecord?.counts;
+    if (stageCounts && typeof stageCounts === "object" && !Array.isArray(stageCounts)) {
+        for (const [key, value] of Object.entries(stageCounts)) {
+            if (typeof value === "number" && Number.isFinite(value)) {
+                merged[key] = value;
+            }
+        }
+    }
+    return merged;
+}
+export function validateCompiled(dirPath) {
+    const context = readWorkflowContext(dirPath);
+    return {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_valid: context.schema !== null,
+    };
+}
+export function validateCompiledStage(dirPath, stageId) {
+    const context = readWorkflowContext(dirPath);
+    const checks = {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_valid: context.schema !== null,
+    };
+    const errors = [];
+    if (!checks.config_present)
+        errors.push(`Missing ${compiledInterfConfigPath(dirPath)}.`);
+    else if (!checks.config_valid)
+        errors.push(`Could not parse ${compiledInterfConfigPath(dirPath)}.`);
+    else if (!checks.config_type_match)
+        errors.push("Config is not a compiled dataset.");
+    if (!checks.workflow_present)
+        errors.push("Missing .interf/workflow/workflow.json.");
+    else if (!checks.workflow_valid)
+        errors.push("Could not load the active workflow package.");
+    if (!checks.schema_present)
+        errors.push("Missing .interf/workflow/compiled.schema.json.");
+    else if (!checks.schema_valid)
+        errors.push("Could not parse .interf/workflow/compiled.schema.json.");
+    const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
+    checks.stage_present = workflowStage !== null;
+    if (!checks.stage_present) {
+        errors.push(`Workflow does not declare stage "${stageId}".`);
+    }
+    const stageRecord = stageRecordFromState(context.state, stageId);
+    checks.stage_record_present = stageRecord !== null;
+    checks.stage_finished = Boolean(stageRecord?.finished_at);
+    checks.stage_succeeded = stageRecord?.status === "succeeded";
+    const writeCounts = workflowStage && context.schema
+        ? zoneWriteCount(dirPath, context.schema, workflowStage)
+        : { total: 0, zoneCounts: {} };
+    const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
+    const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
+    let acceptanceErrors = [];
+    if (workflowStage && context.schema) {
+        const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
+            stageId,
+            acceptance: workflowStage.acceptance,
+            counts: acceptanceCounts,
+        });
+        checks.acceptance_ok = acceptanceValidation.ok;
+        acceptanceErrors = acceptanceValidation.failures;
+    }
+    else {
+        checks.acceptance_ok = false;
+    }
+    if (required && checks.stage_record_present && !checks.stage_finished) {
+        errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
+    }
+    if (required && checks.stage_record_present && !checks.stage_succeeded) {
+        errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
+    }
+    if (required) {
+        errors.push(...acceptanceErrors);
+    }
+    const ok = required ? errors.length === 0 : errors.length === 0;
+    const summary = !required
+        ? `Stage "${stageId}" is not required yet.`
+        : ok
+            ? `Stage "${stageId}" verified.`
+            : `Stage "${stageId}" failed — ${errors[0] ?? "acceptance not satisfied."}`;
+    return {
+        ok,
+        required,
+        stage: stageId,
+        summary,
+        counts: {
+            ...acceptanceCounts,
+            write_artifacts: writeCounts.total,
+            declared_write_zones: workflowStage?.writes.length ?? 0,
+        },
+        checks,
+        errors,
+    };
+}
+export function validateCompiledWorkflow(dirPath) {
+    const context = readWorkflowContext(dirPath);
+    const checks = {
+        config_present: context.config.present,
+        config_valid: context.config.valid,
+        config_type_match: context.config.typeMatch(),
+        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
+        workflow_valid: context.workflow !== null,
+        schema_present: existsSync(join(dirPath, ".interf", "workflow", "compiled.schema.json")),
+        schema_valid: context.schema !== null,
+    };
+    if (!context.workflow) {
+        const errors = ["Could not load the active workflow package."];
+        return {
+            ok: false,
+            required: true,
+            stage: "workflow",
+            summary: `Compiled workflow failed — ${errors[0]}`,
+            counts: { source_total: context.sourceTotal, stage_total: 0, completed_stages: 0 },
+            checks,
+            errors,
+            stage_results: {},
+        };
+    }
+    const stageResults = {};
+    const errors = [];
+    let completedStages = 0;
+    let failedStage = "compiled";
+    for (const stage of context.workflow.stages) {
+        const validation = validateCompiledStage(dirPath, stage.id);
+        stageResults[stage.id] = validation.ok;
+        if (validation.ok) {
+            completedStages += 1;
+            continue;
+        }
+        failedStage = stage.id;
+        errors.push(...validation.errors);
+        break;
+    }
+    const ok = errors.length === 0;
+    return {
+        ok,
+        required: context.sourceTotal > 0,
+        stage: failedStage,
+        summary: ok
+            ? `Compiled workflow verified — ${completedStages}/${context.workflow.stages.length} stages satisfied.`
+            : `Compiled workflow failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
+        counts: {
+            source_total: context.sourceTotal,
+            stage_total: context.workflow.stages.length,
+            completed_stages: completedStages,
+        },
+        checks,
+        errors,
+        stage_results: stageResults,
+    };
+}
+export function validateCompiledSummarize(dirPath) {
+    return validateCompiledStage(dirPath, "summarize");
+}
+export function validateCompiledStructure(dirPath) {
+    return validateCompiledStage(dirPath, "structure");
+}
+export function validateCompiledCompile(dirPath) {
+    return validateCompiledWorkflow(dirPath);
+}

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

@@ -10,11 +10,3 @@ export declare function isSubset(left: Set<string>, right: Set<string>): boolean
 export declare function setsEqual(left: Set<string>, right: Set<string>): boolean;
 export declare function setIntersectionSize(left: Set<string>, right: Set<string>): number;
 export declare function dedupeStrings(values: string[]): string[];
-export interface InventoryFiles {
-    legacyFiles: Array<Record<string, unknown>>;
-    summaryFiles: Array<Record<string, unknown>>;
-    entryFiles: Array<Record<string, unknown>>;
-    files: Array<Record<string, unknown>>;
-}
-export declare function readInventoryFiles(inventory: Record<string, unknown> | null): InventoryFiles;
-export declare function readInventoryTotal(inventory: Record<string, unknown> | null, inventoryFiles?: InventoryFiles): number;

package/dist/lib/validate-helpers.js

@@ -39,33 +39,3 @@ export function setIntersectionSize(left, right) {
 export function dedupeStrings(values) {
     return Array.from(new Set(values));
 }
-function asInventoryEntries(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => !!item && typeof item === "object" && !Array.isArray(item));
-}
-export function readInventoryFiles(inventory) {
-    const legacyFiles = asInventoryEntries(inventory?.files);
-    const summaryFiles = asInventoryEntries(inventory?.summaries);
-    const entryFiles = asInventoryEntries(inventory?.entries);
-    const itemFiles = asInventoryEntries(inventory?.items);
-    const normalizedEntryFiles = entryFiles.length > 0 ? entryFiles : itemFiles;
-    const files = legacyFiles.length > 0
-        ? legacyFiles
-        : summaryFiles.length > 0
-            ? summaryFiles
-            : normalizedEntryFiles;
-    return {
-        legacyFiles,
-        summaryFiles,
-        entryFiles: normalizedEntryFiles,
-        files,
-    };
-}
-export function readInventoryTotal(inventory, inventoryFiles) {
-    if (typeof inventory?.total === "number")
-        return inventory.total;
-    if (typeof inventory?.summary_total === "number")
-        return inventory.summary_total;
-    return (inventoryFiles ?? readInventoryFiles(inventory)).files.length;
-}

package/dist/lib/validate.d.ts

@@ -1,5 +1,5 @@
 import { readInterfConfig } from "./interf.js";
-export declare function readWorkspaceConfig(dirPath: string): {
+export declare function readCompiledConfig(dirPath: string): {
     present: boolean;
     valid: boolean;
     value: ReturnType<typeof readInterfConfig>;
@@ -9,9 +9,9 @@ export declare function validateSynthFiles(files: string[]): {
     invalid_frontmatter: number;
     short_abstracts: number;
 };
-export declare function countBrokenWikilinks(workspaceRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
+export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
 export declare function asNumber(value: unknown): number;
 export declare function isOutputMarkdownFile(filePath: string): boolean;
 export declare function safeReadText(filePath: string): string | null;
-export { validateWorkspace, validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "./validate-workspace.js";
-export type { WorkspaceValidationSummary, WorkspaceSummarizeValidation, WorkspaceStructureValidation, WorkspaceCompileValidation, } from "./validate-workspace.js";
+export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
+export type { CompiledValidationSummary, CompiledStageValidation, CompiledWorkflowValidation, } from "./validate-compiled.js";

package/dist/lib/validate.js

@@ -1,9 +1,12 @@
 import { existsSync, readFileSync, statSync, } from "node:fs";
 import { basename, extname, join } from "node:path";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { compiledKnowledgeRootPath } from "./compiled-schema.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { listFilesRecursive } from "./filesystem.js";
 import { readInterfConfig } from "./interf.js";
 import { parseJsonFrontmatter } from "./parse.js";
-import { workspaceInterfConfigPath } from "./workspace-paths.js";
+import { compiledInterfConfigPath } from "./compiled-paths.js";
 const REQUIRED_DIGEST_FIELDS = [
     "source_kind",
     "evidence_tier",
@@ -12,9 +15,8 @@ const REQUIRED_DIGEST_FIELDS = [
 ];
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
-const KNOWLEDGE_RELATIVE_PREFIXES = new Set(["entities", "claims", "indexes"]);
-export function readWorkspaceConfig(dirPath) {
-    const configPath = workspaceInterfConfigPath(dirPath);
+export function readCompiledConfig(dirPath) {
+    const configPath = compiledInterfConfigPath(dirPath);
     const value = readInterfConfig(dirPath);
     const present = existsSync(configPath);
     if (!present) {
@@ -30,7 +32,7 @@ export function readWorkspaceConfig(dirPath) {
         valid: value !== null,
         value,
         typeMatch() {
-            return value?.type === "workspace" && typeof value?.source?.path === "string";
+            return value?.type === "compiled" && typeof value?.source?.path === "string";
         },
     };
 }
@@ -56,7 +58,9 @@ export function validateSynthFiles(files) {
         short_abstracts: shortAbstracts,
     };
 }
-export function countBrokenWikilinks(workspaceRoot, noteIndexRoots, linkScanRoots) {
+export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
+    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
+    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
     const noteIndex = new Set();
     for (const filePath of dedupeFiles(noteIndexRoots)) {
         for (const target of collectWikilinkTargets(filePath)) {
@@ -77,12 +81,15 @@ export function countBrokenWikilinks(workspaceRoot, noteIndexRoots, linkScanRoot
             if (!target)
                 continue;
             if (target.includes("/")) {
-                if (!wikilinkPathExists(workspaceRoot, target)) {
+                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)) {
                     brokenLinks += 1;
                 }
                 continue;
             }
-            if (!noteIndex.has(target.toLowerCase())) {
+            if (!noteIndex.has(target.toLowerCase()) &&
+                !noteIndex.has(noteName(target).toLowerCase()) &&
+                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes)) {
                 brokenLinks += 1;
             }
         }
@@ -157,15 +164,23 @@ function countWords(text) {
 function noteName(filePath) {
     return basename(filePath, extname(filePath));
 }
-function wikilinkPathExists(workspaceRoot, target) {
-    return linkPathCandidates(workspaceRoot, target).some((candidate) => existsSync(candidate));
+function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
+    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes)
+        .some((candidate) => existsSync(candidate));
 }
-function linkPathCandidates(workspaceRoot, target) {
+function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes) {
     const candidates = new Set();
-    addPathCandidate(candidates, join(workspaceRoot, target));
+    addPathCandidate(candidates, join(compiledRoot, target));
     const [firstSegment] = target.split("/");
-    if (firstSegment && KNOWLEDGE_RELATIVE_PREFIXES.has(firstSegment)) {
-        addPathCandidate(candidates, join(workspaceRoot, "knowledge", target));
+    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
+        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
+    }
+    if (firstSegment) {
+        const normalizedPrefix = zonePathById.get(firstSegment);
+        if (normalizedPrefix) {
+            const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
+            addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
+        }
     }
     return Array.from(candidates);
 }
@@ -175,6 +190,25 @@ function addPathCandidate(candidates, absolutePath) {
         candidates.add(`${absolutePath}.md`);
     }
 }
+function compiledZoneDirectoryPaths(compiledRoot) {
+    const workflowRoot = workflowPackagePathForCompiled(compiledRoot);
+    const schema = readCompiledSchemaFile(workflowRoot);
+    if (!schema)
+        return new Map();
+    return new Map(schema.zones
+        .filter((zone) => zone.kind === "directory")
+        .map((zone) => [zone.id, zone.path]));
+}
+function compiledKnowledgeRelativePrefixes(zonePathById) {
+    const prefixes = new Set();
+    for (const zonePath of zonePathById.values()) {
+        const [root, leaf, ...rest] = zonePath.split("/");
+        if (root !== "knowledge" || !leaf || rest.length > 0)
+            continue;
+        prefixes.add(leaf);
+    }
+    return prefixes;
+}
 function collectWikilinkTargets(filePath) {
     const targets = new Set();
     targets.add(noteName(filePath));
@@ -204,4 +238,4 @@ function addFrontmatterLinkTarget(targets, value) {
         }
     }
 }
-export { validateWorkspace, validateWorkspaceSummarize, validateWorkspaceStructure, validateWorkspaceCompile, } from "./validate-workspace.js";
+export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";

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

@@ -1,28 +1,28 @@
-export declare const WORKSPACE_CONTRACT_TYPES: readonly ["workspace-file-evidence", "workspace-knowledge-structure", "workspace-query-shape"];
-export type WorkspaceContractType = typeof WORKSPACE_CONTRACT_TYPES[number];
-export declare const WORKSPACE_ZONE_KINDS: readonly ["directory", "file", "runtime"];
-export type WorkspaceZoneKind = typeof WORKSPACE_ZONE_KINDS[number];
-export declare const WORKSPACE_CONTRACT_FAMILY_METADATA: {
-    readonly "workspace-file-evidence": {
+export declare const COMPILED_CONTRACT_TYPES: readonly ["compiled-file-evidence", "compiled-knowledge-structure", "compiled-query-shape"];
+export type CompiledContractType = typeof COMPILED_CONTRACT_TYPES[number];
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];
+export declare const COMPILED_CONTRACT_FAMILY_METADATA: {
+    readonly "compiled-file-evidence": {
         readonly order: 0;
         readonly bundledSkill: "compile/stages/summarize";
     };
-    readonly "workspace-knowledge-structure": {
+    readonly "compiled-knowledge-structure": {
         readonly order: 1;
         readonly bundledSkill: "compile/stages/structure";
     };
-    readonly "workspace-query-shape": {
+    readonly "compiled-query-shape": {
         readonly order: 2;
         readonly bundledSkill: "compile/stages/shape";
     };
 };
-export declare const BUILTIN_WORKSPACE_STAGE_IDS: {
+export declare const BUILTIN_COMPILED_STAGE_IDS: {
     readonly SUMMARIZE: "summarize";
     readonly STRUCTURE: "structure";
     readonly SHAPE: "shape";
 };
-export type BuiltinWorkspaceStageId = typeof BUILTIN_WORKSPACE_STAGE_IDS[keyof typeof BUILTIN_WORKSPACE_STAGE_IDS];
-export declare const BUILTIN_WORKSPACE_ZONE_IDS: {
+export type BuiltinCompiledStageId = typeof BUILTIN_COMPILED_STAGE_IDS[keyof typeof BUILTIN_COMPILED_STAGE_IDS];
+export declare const BUILTIN_COMPILED_ZONE_IDS: {
     readonly RAW: "raw";
     readonly SUMMARIES: "summaries";
     readonly KNOWLEDGE_ENTITIES: "knowledge-entities";
@@ -31,20 +31,20 @@ export declare const BUILTIN_WORKSPACE_ZONE_IDS: {
     readonly HOME: "home";
     readonly RUNTIME: "runtime";
 };
-export type BuiltinWorkspaceZoneId = typeof BUILTIN_WORKSPACE_ZONE_IDS[keyof typeof BUILTIN_WORKSPACE_ZONE_IDS];
-export interface BuiltinWorkspaceZoneSpec {
-    id: BuiltinWorkspaceZoneId;
+export type BuiltinCompiledZoneId = typeof BUILTIN_COMPILED_ZONE_IDS[keyof typeof BUILTIN_COMPILED_ZONE_IDS];
+export interface BuiltinCompiledZoneSpec {
+    id: BuiltinCompiledZoneId;
     path: string;
-    kind: WorkspaceZoneKind;
+    kind: CompiledZoneKind;
     required: true;
     description: string;
 }
-export declare const BUILTIN_WORKSPACE_ZONE_SPECS: readonly [{
+export declare const BUILTIN_COMPILED_ZONE_SPECS: readonly [{
     readonly id: "raw";
     readonly path: "raw";
     readonly kind: "directory";
     readonly required: true;
-    readonly description: "Workspace-local raw snapshot copied from the dataset for direct evidence and verification.";
+    readonly description: "Compiled-local raw snapshot copied from the dataset for direct evidence and verification.";
 }, {
     readonly id: "summaries";
     readonly path: "summaries";
@@ -74,7 +74,7 @@ export declare const BUILTIN_WORKSPACE_ZONE_SPECS: readonly [{
     readonly path: "home.md";
     readonly kind: "file";
     readonly required: true;
-    readonly description: "Primary entrypoint note for agents using the compiled workspace.";
+    readonly description: "Primary entrypoint note for agents using the compiled dataset.";
 }, {
     readonly id: "runtime";
     readonly path: ".interf/runtime";
@@ -82,20 +82,20 @@ export declare const BUILTIN_WORKSPACE_ZONE_SPECS: readonly [{
     readonly required: true;
     readonly description: "CLI-owned runtime state, health, stage contracts, and proof artifacts.";
 }];
-export interface BuiltinWorkspaceStageAccessPattern {
-    id: BuiltinWorkspaceStageId;
+export interface BuiltinCompiledStageAccessPattern {
+    id: BuiltinCompiledStageId;
     label: string;
     description: string;
-    contractType: WorkspaceContractType;
+    contractType: CompiledContractType;
     skillDir: string;
-    reads: readonly BuiltinWorkspaceZoneId[];
-    writes: readonly BuiltinWorkspaceZoneId[];
+    reads: readonly BuiltinCompiledZoneId[];
+    writes: readonly BuiltinCompiledZoneId[];
 }
-export declare const BUILTIN_WORKSPACE_STAGE_ACCESS_PATTERNS: readonly [{
+export declare const BUILTIN_COMPILED_STAGE_ACCESS_PATTERNS: readonly [{
     readonly id: "summarize";
     readonly label: "Summarize";
     readonly description: "Turn source files into per-file summaries.";
-    readonly contractType: "workspace-file-evidence";
+    readonly contractType: "compiled-file-evidence";
     readonly skillDir: "summarize";
     readonly reads: readonly ["raw", "runtime"];
     readonly writes: readonly ["summaries"];
@@ -103,36 +103,27 @@ export declare const BUILTIN_WORKSPACE_STAGE_ACCESS_PATTERNS: readonly [{
     readonly id: "structure";
     readonly label: "Structure";
     readonly description: "Build the cross-file knowledge structure from the summaries.";
-    readonly contractType: "workspace-knowledge-structure";
+    readonly contractType: "compiled-knowledge-structure";
     readonly skillDir: "structure";
     readonly reads: readonly ["summaries", "runtime"];
     readonly writes: readonly ["knowledge-entities", "knowledge-claims", "knowledge-indexes"];
 }, {
     readonly id: "shape";
     readonly label: "Shape";
-    readonly description: "Shape the final workspace around the saved focus and truth checks.";
-    readonly contractType: "workspace-query-shape";
+    readonly description: "Shape the final compiled around the saved focus and truth checks.";
+    readonly contractType: "compiled-query-shape";
     readonly skillDir: "shape";
     readonly reads: readonly ["raw", "summaries", "knowledge-entities", "knowledge-claims", "knowledge-indexes", "runtime"];
     readonly writes: readonly ["knowledge-indexes", "home"];
 }];
-export declare function workspaceContractOrder(contractType: WorkspaceContractType): number;
-export declare function workspaceBundledSkillForContractType(contractType: WorkspaceContractType): string;
-export declare function hasValidWorkspaceContractSequence(contractTypes: readonly WorkspaceContractType[]): boolean;
-export declare function listMissingWorkspaceContractTypes(contractTypes: readonly string[]): WorkspaceContractType[];
-export declare function validateWorkspaceContractSequence(contractTypes: readonly WorkspaceContractType[]): {
-    ok: boolean;
-    orderValid: boolean;
-    missing: WorkspaceContractType[];
-};
-export declare function listBuiltinWorkspaceZoneSpecs(): BuiltinWorkspaceZoneSpec[];
-export declare function listBuiltinWorkspaceFallbackStages(): Array<{
-    id: BuiltinWorkspaceStageId;
-    contract_type: WorkspaceContractType;
-    reads: BuiltinWorkspaceZoneId[];
-    writes: BuiltinWorkspaceZoneId[];
+export declare function listBuiltinCompiledZoneSpecs(): BuiltinCompiledZoneSpec[];
+export declare function listBuiltinCompiledFallbackStages(): Array<{
+    id: BuiltinCompiledStageId;
+    contract_type: CompiledContractType;
+    reads: BuiltinCompiledZoneId[];
+    writes: BuiltinCompiledZoneId[];
 }>;
-export declare function requiredWorkspaceZoneOwners<TStage extends {
+export declare function requiredCompiledZoneOwners<TStage extends {
     id: string;
-    contractType: WorkspaceContractType;
-}>(stages: readonly TStage[], zoneId: BuiltinWorkspaceZoneId): string[];
+    writes: readonly string[];
+}>(stages: readonly TStage[], zoneId: BuiltinCompiledZoneId): string[];