@interf/compiler 0.4.1 → 0.5.1

package/dist/lib/state-health.js

@@ -1,148 +1,132 @@
 import { basename, join } from "node:path";
 import { existsSync } from "node:fs";
-import { countFilesRecursive } from "./filesystem.js";
-import { discoverSourceFiles } from "./discovery.js";
 import { readInterfConfig, resolveSourceFolderPath, } from "./interf.js";
+import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
-import { validateWorkspace } from "./validate.js";
-import { initWorkspaceState, loadState, } from "./state-io.js";
-import { workspaceRuntimeInventoryPath } from "./workspace-paths.js";
-export function computeWorkspaceHealth(dirPath) {
-    const state = {
-        ...initWorkspaceState(),
-        ...(loadState(dirPath) ?? {}),
-    };
-    const validation = validateWorkspace(dirPath);
+import { loadState } from "./state-io.js";
+import { validateCompiled, validateCompiledStage, validateCompiledWorkflow, } from "./validate.js";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+import { listFilesRecursive } from "./filesystem.js";
+function countZoneArtifacts(compiledPath, zonePath, kind) {
+    const absolutePath = join(compiledPath, zonePath);
+    if (!existsSync(absolutePath))
+        return 0;
+    if (kind === "file")
+        return 1;
+    return listFilesRecursive(absolutePath).length;
+}
+export function computeCompiledHealth(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
-    const workspaceName = config?.name ?? basename(dirPath);
-    const sourcePath = resolveSourceFolderPath(dirPath, config);
-    const discovery = discoverSourceFiles(sourcePath, dirPath);
-    const summariesPresent = existsSync(join(dirPath, "summaries"));
-    const inventoryPresent = existsSync(workspaceRuntimeInventoryPath(dirPath));
-    const homePresent = existsSync(join(dirPath, "home.md"));
-    const outputs = countOutputFiles(dirPath);
-    const outputsPresent = outputs > 0;
-    const sourceTotal = discovery.totalCount;
-    const summarized = summariesPresent ? countFilesRecursive(join(dirPath, "summaries")) : 0;
-    const sourceCovered = Math.min(sourceTotal, summarized);
-    const structured = Math.min(summarized, Math.max(state.structured ?? 0, state.compiled ?? 0));
-    const compiled = Math.min(summarized, Math.max(state.shaped ?? 0, state.compiled ?? 0));
-    const toSummarize = Math.max(0, sourceTotal - sourceCovered);
-    const toStructure = Math.max(0, summarized - structured);
-    const toShape = Math.max(0, structured - compiled);
-    const warnings = (toSummarize > 0 ? 1 : 0) +
-        (toStructure > 0 ? 1 : 0) +
-        (toShape > 0 ? 1 : 0) +
-        (summarized > sourceTotal && sourceTotal > 0 ? 1 : 0) +
-        (!outputsPresent && state.last_compile ? 1 : 0) +
-        validation.invalid_frontmatter +
-        validation.short_abstracts +
-        validation.broken_links;
-    const errors = (!validation.config_present ? 1 : 0) +
-        (!validation.config_valid && validation.config_present ? 1 : 0) +
-        (!validation.config_type_match && validation.config_valid ? 1 : 0) +
-        (state.error_count ?? 0);
+    const targetName = config?.name ?? basename(dirPath);
+    const sourcePath = config ? resolveSourceFolderPath(dirPath, config) : dirPath;
+    const sourceTotal = config ? discoverSourceFiles(sourcePath, dirPath).totalCount : 0;
+    const state = loadState(dirPath);
+    const validation = validateCompiled(dirPath);
     const activeRun = loadRuntimeRun(dirPath);
-    const inferredStage = resolveWorkspaceStage(state, sourceTotal, summarized, toSummarize, toStructure, toShape, errors);
-    const inferredStatus = resolveWorkspaceStatus(sourceTotal, summarized, toSummarize, toStructure, toShape, errors, state);
-    const stage = activeRun?.status === "running"
-        ? activeRun.stage === "summarize" || activeRun.stage === "structure" || activeRun.stage === "shape"
-            ? activeRun.stage
-            : inferredStage
-        : inferredStage;
-    const status = activeRun?.status === "running" ? "running" : inferredStatus;
+    const workflowId = config
+        ? resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`)
+        : null;
+    let workflow = null;
+    if (workflowId) {
+        try {
+            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+        }
+        catch {
+            workflow = null;
+        }
+    }
+    const stageResults = workflow?.stages.map((stage) => ({
+        stage,
+        validation: validateCompiledStage(dirPath, stage.id),
+    })) ?? [];
+    const completedStages = stageResults.filter((entry) => entry.validation.ok).length;
+    const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
+    const workflowValidation = validateCompiledWorkflow(dirPath);
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const zoneMetrics = Object.fromEntries((schema?.zones ?? []).map((zone) => [
+        `zone_${zone.id}`,
+        countZoneArtifacts(dirPath, zone.path, zone.kind),
+    ]));
+    let status = "idle";
+    let stage = "idle";
+    let summary = "Idle — no source files have been compiled yet.";
+    const errors = workflowValidation.errors.length;
+    if (!validation.config_present || !validation.config_valid || !validation.config_type_match || !validation.workflow_valid || !validation.schema_valid) {
+        status = "failed";
+        stage = "failed";
+        summary = workflowValidation.summary;
+    }
+    else if (activeRun?.status === "running") {
+        status = "running";
+        stage = activeRun.stage;
+        summary = `Running — ${activeRun.stage_label} via ${activeRun.executor.display_name}. ${activeRun.summary}`;
+    }
+    else if (sourceTotal === 0 && completedStages === 0) {
+        status = "idle";
+        stage = "idle";
+        summary = "Idle — no source files have been compiled yet.";
+    }
+    else if (activeRun?.status === "failed") {
+        status = "failed";
+        stage = activeRun.stage;
+        summary = activeRun.error ?? activeRun.summary;
+    }
+    else if (workflowValidation.ok) {
+        status = "compiled";
+        stage = "compiled";
+        summary = `Compiled — ${completedStages}/${workflow?.stages.length ?? 0} workflow stages satisfied.`;
+    }
+    else {
+        status = "stale";
+        stage = firstFailed?.stage.id ?? "compiled";
+        summary = firstFailed?.validation.summary ?? workflowValidation.summary;
+    }
+    const checks = {
+        ...validation,
+        ...(workflow
+            ? Object.fromEntries(workflow.stages.map((workflowStage) => [
+                `stage_${workflowStage.id}_ok`,
+                stageResults.find((entry) => entry.stage.id === workflowStage.id)?.validation.ok ?? false,
+            ]))
+            : {}),
+    };
     return {
-        kind: "workspace-health",
-        version: 1,
+        kind: "compiled-health",
+        version: 2,
         generated_at: now,
-        target_name: workspaceName,
+        target_name: targetName,
         status,
         stage,
-        summary: activeRun?.status === "running"
-            ? `Running — ${activeRun.stage_label} via ${activeRun.executor.display_name}. ${activeRun.summary}`
-            : buildWorkspaceSummary(status, stage, {
-                sourceTotal,
-                sourceCovered,
-                summarized,
-                toSummarize,
-                structured,
-                toStructure,
-                compiled,
-                toCompile: toShape,
-            }),
+        summary,
         metrics: {
             source_total: sourceTotal,
-            source_covered: sourceCovered,
-            summarized,
-            to_summarize: toSummarize,
-            compiled,
-            to_compile: toShape,
-            entities: state.entity_count ?? countFilesRecursive(join(dirPath, "knowledge", "entities")),
-            claims: state.claim_count ?? countFilesRecursive(join(dirPath, "knowledge", "claims")),
-            outputs,
-            invalid_frontmatter: validation.invalid_frontmatter,
-            short_abstracts: validation.short_abstracts,
-            broken_links: validation.broken_links,
-            warnings: (state.warning_count ?? 0) + warnings,
-            errors,
-        },
-        checks: {
-            config_present: validation.config_present,
-            config_valid: validation.config_valid,
-            config_type_match: validation.config_type_match,
-            summaries_present: summariesPresent,
-            inventory_present: inventoryPresent,
-            outputs_present: outputsPresent,
-            home_present: homePresent,
-            summary_frontmatter_valid: validation.summary_frontmatter_valid,
-            abstracts_valid: validation.abstracts_valid,
-            links_valid: validation.broken_links === 0,
+            stage_total: workflow?.stages.length ?? 0,
+            completed_stages: completedStages,
+            warnings: state?.warning_count ?? 0,
+            errors: (state?.error_count ?? 0) + errors,
+            ...zoneMetrics,
         },
+        checks,
     };
 }
-export function resolveWorkspaceStatus(sourceTotal, summarized, toSummarize, toStructure, toShape, errors, state) {
-    if (errors > 0)
+export function resolveCompiledStatus(..._args) {
+    const state = _args[_args.length - 1];
+    if (state?.error_count && state.error_count > 0)
         return "failed";
-    if (sourceTotal === 0 && summarized === 0 && state.last_summarize === null && state.last_compile === null)
+    if (!state?.stages || Object.keys(state.stages).length === 0)
         return "idle";
-    if (toSummarize > 0 || toStructure > 0 || toShape > 0)
-        return "stale";
-    return "compiled";
+    const allSucceeded = Object.values(state.stages).every((stage) => stage.status === "succeeded");
+    return allSucceeded ? "compiled" : "stale";
 }
-export function resolveWorkspaceStage(state, sourceTotal, summarized, toSummarize, toStructure, toShape, errors) {
-    if (errors > 0)
+export function resolveCompiledStage(...args) {
+    const state = args[0];
+    if (state?.error_count && state.error_count > 0)
         return "failed";
-    if (sourceTotal === 0 && summarized === 0 && state.last_summarize === null && state.last_compile === null)
+    if (!state?.stages || Object.keys(state.stages).length === 0)
         return "idle";
-    if (toSummarize > 0)
-        return "summarize";
-    if (toStructure > 0)
-        return "structure";
-    if (toShape > 0)
-        return "shape";
-    return "compiled";
-}
-function buildWorkspaceSummary(status, stage, metrics) {
-    if (status === "failed")
-        return "Failed — required workspace inputs are missing.";
-    if (status === "idle")
-        return "Idle — no source files have been compiled yet.";
-    if (stage === "summarize") {
-        return `Stale — ${metrics.toSummarize} source files still need summaries (${metrics.sourceCovered}/${metrics.sourceTotal} summarized).`;
-    }
-    if (stage === "structure") {
-        return `Stale — ${metrics.toStructure} summaries still need cross-file structure (${metrics.structured}/${metrics.summarized} structured).`;
-    }
-    if (stage === "shape") {
-        return `Stale — ${metrics.toCompile} summaries still need final workspace shaping (${metrics.compiled}/${metrics.summarized} shaped).`;
-    }
-    return `Compiled — ${metrics.compiled}/${metrics.summarized} summaries compiled, ${metrics.sourceCovered}/${metrics.sourceTotal} source files summarized.`;
-}
-function countOutputFiles(dirPath) {
-    return [
-        join(dirPath, "knowledge", "entities"),
-        join(dirPath, "knowledge", "claims"),
-        join(dirPath, "knowledge", "indexes"),
-    ].reduce((total, dir) => total + countFilesRecursive(dir), 0);
+    const failedStage = Object.entries(state.stages).find(([, stage]) => stage.status !== "succeeded");
+    return failedStage?.[0] ?? "compiled";
 }

package/dist/lib/state-io.d.ts

@@ -1,10 +1,10 @@
-import { type WorkspaceHealth, type WorkspaceRawSnapshot, type WorkspaceState, type WorkspaceViewSpec } from "./schema.js";
+import { type CompiledHealth, type CompiledRawSnapshot, type CompiledState, type CompiledViewSpec } from "./schema.js";
 export declare function loadState<T>(dirPath: string): T | null;
 export declare function saveState<T>(dirPath: string, state: T): void;
-export declare function loadWorkspaceHealth(dirPath: string): WorkspaceHealth | null;
-export declare function saveWorkspaceHealth(dirPath: string, health: WorkspaceHealth): void;
-export declare function loadWorkspaceViewSpec(dirPath: string): WorkspaceViewSpec | null;
-export declare function saveWorkspaceViewSpec(dirPath: string, viewSpec: WorkspaceViewSpec): void;
-export declare function loadWorkspaceRawSnapshot(dirPath: string): WorkspaceRawSnapshot | null;
-export declare function saveEmptyWorkspaceInventory(dirPath: string): void;
-export declare function initWorkspaceState(): WorkspaceState;
+export declare function loadCompiledHealth(dirPath: string): CompiledHealth | null;
+export declare function saveCompiledHealth(dirPath: string, health: CompiledHealth): void;
+export declare function loadCompiledViewSpec(dirPath: string): CompiledViewSpec | null;
+export declare function saveCompiledViewSpec(dirPath: string, viewSpec: CompiledViewSpec): void;
+export declare function loadCompiledRawSnapshot(dirPath: string): CompiledRawSnapshot | null;
+export declare function saveEmptyCompiledInventory(dirPath: string): void;
+export declare function initCompiledState(): CompiledState;

package/dist/lib/state-io.js

@@ -1,17 +1,10 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { warnInterf } from "./logger.js";
 import { readJsonFileUnchecked, readJsonFileWithSchema } from "./parse.js";
-import { WorkspaceHealthSchema, WorkspaceInventorySchema, WorkspaceRawSnapshotSchema, WorkspaceStateSchema, WorkspaceViewSpecSchema, } from "./schema.js";
-import { readInventoryFiles, readInventoryTotal } from "./validate-helpers.js";
+import { CompiledHealthSchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./schema.js";
+import { emptyCompiledInventory, } from "./runtime-inventory.js";
 import { healthPath, rawSnapshotPath, statePath, viewSpecPath } from "./state-paths.js";
-import { workspaceRuntimeInventoryPath, workspaceRuntimeRoot, } from "./workspace-paths.js";
-const NORMALIZABLE_RUNTIME_TIMESTAMP_FIELDS = [
-    "last_add",
-    "last_summarize",
-    "last_structure",
-    "last_shape",
-    "last_compile",
-];
+import { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
 export function loadState(dirPath) {
     const path = statePath(dirPath);
     if (!existsSync(path))
@@ -19,132 +12,58 @@ export function loadState(dirPath) {
     const raw = readJsonFileUnchecked(path, "runtime state");
     if (raw === null)
         return null;
-    const parsed = WorkspaceStateSchema.safeParse(raw);
+    const parsed = CompiledStateSchema.safeParse(raw);
     if (parsed.success) {
-        const healed = healParsedRuntimeState(dirPath, parsed.data);
-        if (healed !== null) {
-            saveState(dirPath, healed);
-            return healed;
-        }
         return parsed.data;
     }
-    const normalized = normalizeRuntimeState(raw);
-    if (normalized !== null) {
-        saveState(dirPath, normalized);
-        return normalized;
-    }
     warnInterf(`Warning: failed to validate runtime state at ${path}: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
     return null;
 }
 export function saveState(dirPath, state) {
-    mkdirSync(workspaceRuntimeRoot(dirPath), { recursive: true });
+    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(statePath(dirPath), JSON.stringify(state, null, 2) + "\n");
 }
-export function loadWorkspaceHealth(dirPath) {
+export function loadCompiledHealth(dirPath) {
     const path = healthPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "workspace health", WorkspaceHealthSchema);
+    return readJsonFileWithSchema(path, "compiled health", CompiledHealthSchema);
 }
-export function saveWorkspaceHealth(dirPath, health) {
-    mkdirSync(workspaceRuntimeRoot(dirPath), { recursive: true });
+export function saveCompiledHealth(dirPath, health) {
+    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(healthPath(dirPath), JSON.stringify(health, null, 2) + "\n");
 }
-export function loadWorkspaceViewSpec(dirPath) {
+export function loadCompiledViewSpec(dirPath) {
     const path = viewSpecPath(dirPath);
     if (!existsSync(path))
         return null;
-    return loadViewSpec(path, WorkspaceViewSpecSchema);
+    return loadViewSpec(path, CompiledViewSpecSchema);
 }
-export function saveWorkspaceViewSpec(dirPath, viewSpec) {
-    mkdirSync(workspaceRuntimeRoot(dirPath), { recursive: true });
+export function saveCompiledViewSpec(dirPath, viewSpec) {
+    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(viewSpecPath(dirPath), JSON.stringify(viewSpec, null, 2) + "\n");
 }
-export function loadWorkspaceRawSnapshot(dirPath) {
+export function loadCompiledRawSnapshot(dirPath) {
     const path = rawSnapshotPath(dirPath);
     if (!existsSync(path))
         return null;
-    return readJsonFileWithSchema(path, "workspace raw snapshot", WorkspaceRawSnapshotSchema);
+    return readJsonFileWithSchema(path, "compiled raw snapshot", CompiledRawSnapshotSchema);
 }
-export function saveEmptyWorkspaceInventory(dirPath) {
-    mkdirSync(workspaceRuntimeRoot(dirPath), { recursive: true });
-    writeFileSync(workspaceRuntimeInventoryPath(dirPath), JSON.stringify({ entries: [], total: 0 }, null, 2) + "\n");
+export function saveEmptyCompiledInventory(dirPath) {
+    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
+    writeFileSync(compiledRuntimeInventoryPath(dirPath), JSON.stringify(emptyCompiledInventory(), null, 2) + "\n");
 }
-export function initWorkspaceState() {
+export function initCompiledState() {
     return {
-        version: 1,
+        version: 2,
         pending: [],
-        summarized: 0,
-        structured: 0,
-        shaped: 0,
-        compiled: 0,
+        stages: {},
         last_add: null,
-        last_summarize: null,
-        last_structure: null,
-        last_shape: null,
         last_compile: null,
-        inventory_complete: false,
-        abstracts_read: 0,
-        full_reads: 0,
-        entity_count: 0,
-        claim_count: 0,
         warning_count: 0,
         error_count: 0,
     };
 }
-function normalizeRuntimeState(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return null;
-    const normalized = { ...raw };
-    let changed = false;
-    for (const field of NORMALIZABLE_RUNTIME_TIMESTAMP_FIELDS) {
-        const timestamp = normalizeRuntimeTimestampField(normalized[field]);
-        if (timestamp !== undefined && timestamp !== normalized[field]) {
-            normalized[field] = timestamp;
-            changed = true;
-        }
-    }
-    if (!changed)
-        return null;
-    const parsed = WorkspaceStateSchema.safeParse(normalized);
-    return parsed.success ? parsed.data : null;
-}
-function healParsedRuntimeState(dirPath, state) {
-    if (typeof state.inventory_complete === "boolean")
-        return null;
-    if (!Array.isArray(state.pending) || state.pending.length > 0)
-        return null;
-    if (typeof state.last_summarize !== "string" || state.last_summarize.length === 0)
-        return null;
-    const inventoryPath = workspaceRuntimeInventoryPath(dirPath);
-    if (!existsSync(inventoryPath))
-        return null;
-    const inventory = readJsonFileWithSchema(inventoryPath, "workspace inventory", WorkspaceInventorySchema);
-    if (inventory === null)
-        return null;
-    const inventoryFiles = readInventoryFiles(inventory);
-    const inventoryTotal = readInventoryTotal(inventory, inventoryFiles);
-    if (inventoryTotal !== state.summarized || inventoryFiles.files.length !== state.summarized)
-        return null;
-    return {
-        ...state,
-        inventory_complete: true,
-    };
-}
-function normalizeRuntimeTimestampField(value) {
-    if (typeof value === "string" || value === null)
-        return value;
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    for (const key of ["generated_at", "finished_at", "updated_at", "started_at", "timestamp"]) {
-        const candidate = record[key];
-        if (typeof candidate === "string" && candidate.length > 0) {
-            return candidate;
-        }
-    }
-    return undefined;
-}
 function loadViewSpec(filePath, schema) {
     try {
         const raw = JSON.parse(readFileSync(filePath, "utf8"));

package/dist/lib/state-paths.js

@@ -1,13 +1,13 @@
-import { workspaceRawSnapshotMetadataPath, workspaceRuntimeHealthPath, workspaceRuntimeStatePath, workspaceRuntimeViewSpecPath, } from "./workspace-paths.js";
+import { compiledRawSnapshotMetadataPath, compiledRuntimeHealthPath, compiledRuntimeStatePath, compiledRuntimeViewSpecPath, } from "./compiled-paths.js";
 export function statePath(dirPath) {
-    return workspaceRuntimeStatePath(dirPath);
+    return compiledRuntimeStatePath(dirPath);
 }
 export function healthPath(dirPath) {
-    return workspaceRuntimeHealthPath(dirPath);
+    return compiledRuntimeHealthPath(dirPath);
 }
 export function viewSpecPath(dirPath) {
-    return workspaceRuntimeViewSpecPath(dirPath);
+    return compiledRuntimeViewSpecPath(dirPath);
 }
 export function rawSnapshotPath(dirPath) {
-    return workspaceRawSnapshotMetadataPath(dirPath);
+    return compiledRawSnapshotMetadataPath(dirPath);
 }

package/dist/lib/state-view.d.ts

@@ -1,4 +1,4 @@
-import { type WorkspaceRawSnapshot, type WorkspaceViewSpec } from "./schema.js";
-export declare function ensureWorkspaceViewSpec(dirPath: string): WorkspaceViewSpec;
-export declare function ensureWorkspaceRawSnapshot(dirPath: string): WorkspaceRawSnapshot;
-export declare function normalizeWorkspaceViewSpec(existing: WorkspaceViewSpec, defaults?: WorkspaceViewSpec): WorkspaceViewSpec;
+import { type CompiledRawSnapshot, type CompiledViewSpec } from "./schema.js";
+export declare function ensureCompiledViewSpec(dirPath: string): CompiledViewSpec;
+export declare function ensureCompiledRawSnapshot(dirPath: string): CompiledRawSnapshot;
+export declare function normalizeCompiledViewSpec(existing: CompiledViewSpec, defaults?: CompiledViewSpec): CompiledViewSpec;

package/dist/lib/state-view.js

@@ -2,28 +2,30 @@ import { basename, relative } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { discoverSourceFiles } from "./discovery.js";
 import { readInterfConfig, resolveSourceFolderPath } from "./interf.js";
-import { loadWorkspaceViewSpec, saveWorkspaceViewSpec, } from "./state-io.js";
+import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { rawSnapshotPath } from "./state-paths.js";
-import { workspaceRuntimeRoot } from "./workspace-paths.js";
-export function ensureWorkspaceViewSpec(dirPath) {
-    const existing = loadWorkspaceViewSpec(dirPath);
+import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
+import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+export function ensureCompiledViewSpec(dirPath) {
+    const existing = loadCompiledViewSpec(dirPath);
     const now = new Date().toISOString();
-    const workspaceName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
-    const defaults = buildDefaultWorkspaceViewSpec(workspaceName, now);
+    const compiledName = readInterfConfig(dirPath)?.name ?? basename(dirPath);
+    const defaults = buildDefaultCompiledViewSpec(dirPath, compiledName, now);
     if (existing) {
-        const normalized = normalizeWorkspaceViewSpec(existing, defaults);
+        const normalized = normalizeCompiledViewSpec(existing, defaults);
         if (JSON.stringify(normalized) !== JSON.stringify(existing)) {
-            saveWorkspaceViewSpec(dirPath, normalized);
+            saveCompiledViewSpec(dirPath, normalized);
         }
         return normalized;
     }
-    saveWorkspaceViewSpec(dirPath, defaults);
+    saveCompiledViewSpec(dirPath, defaults);
     return defaults;
 }
-export function ensureWorkspaceRawSnapshot(dirPath) {
+export function ensureCompiledRawSnapshot(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
-    const workspaceName = config?.name ?? basename(dirPath);
+    const compiledName = config?.name ?? basename(dirPath);
     const sourcePath = resolveSourceFolderPath(dirPath, config);
     const discovery = discoverSourceFiles(sourcePath, dirPath);
     const sampleFiles = [...discovery.sourceFiles]
@@ -31,76 +33,71 @@ export function ensureWorkspaceRawSnapshot(dirPath) {
         .slice(0, 10);
     const sourceRoot = relative(dirPath, sourcePath) || ".";
     const artifact = {
-        kind: "workspace-raw-snapshot",
+        kind: "compiled-raw-snapshot",
         version: 1,
         generated_at: now,
-        target_name: workspaceName,
+        target_name: compiledName,
         source_root: sourceRoot,
         raw_root: sourceRoot,
         source_total: discovery.totalCount,
         sample_files: sampleFiles,
     };
-    mkdirSync(workspaceRuntimeRoot(dirPath), { recursive: true });
+    mkdirSync(compiledRuntimeRoot(dirPath), { recursive: true });
     writeFileSync(rawSnapshotPath(dirPath), JSON.stringify(artifact, null, 2) + "\n");
     return artifact;
 }
-export function normalizeWorkspaceViewSpec(existing, defaults = buildDefaultWorkspaceViewSpec(existing.target_name, existing.generated_at)) {
+export function normalizeCompiledViewSpec(existing, defaults) {
+    const resolvedDefaults = defaults ?? existing;
     return {
-        ...defaults,
+        ...resolvedDefaults,
         ...existing,
-        cards: normalizeWorkspaceCards(existing.cards, defaults.cards),
-        sections: Array.isArray(existing.sections) && existing.sections.length > 0 ? existing.sections : defaults.sections,
+        cards: Array.isArray(existing.cards) && existing.cards.length > 0
+            ? existing.cards.map((card) => {
+                if (card.format !== "fraction" || card.denominator_metric)
+                    return card;
+                const defaultCard = resolvedDefaults.cards.find((candidate) => candidate.id === card.id);
+                return {
+                    ...card,
+                    denominator_metric: defaultCard?.denominator_metric ?? "stage_total",
+                };
+            })
+            : resolvedDefaults.cards,
+        sections: Array.isArray(existing.sections) && existing.sections.length > 0 ? existing.sections : resolvedDefaults.sections,
         graph_scope: Array.isArray(existing.graph_scope) && existing.graph_scope.length > 0
             ? existing.graph_scope
-            : defaults.graph_scope,
+            : resolvedDefaults.graph_scope,
     };
 }
-function buildDefaultWorkspaceViewSpec(workspaceName, generatedAt) {
+function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
+    const config = readInterfConfig(dirPath);
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`);
+    const workflow = getActiveCompiledWorkflow(dirPath, workflowId);
+    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
+    const zoneDocumentPaths = (schema?.zones ?? [])
+        .filter((zone) => zone.kind !== "runtime")
+        .map((zone) => zone.path);
+    const defaultNote = (schema?.zones ?? []).find((zone) => zone.kind === "file")?.path ?? null;
     return {
-        kind: "workspace-view-spec",
-        version: 1,
+        kind: "compiled-view-spec",
+        version: 2,
         generated_at: generatedAt,
-        target_name: workspaceName,
+        target_name: compiledName,
         health_source: ".interf/runtime/health.json",
         state_source: ".interf/runtime/state.json",
-        default_note: "home.md",
-        graph_scope: ["summaries", "knowledge"],
+        default_note: defaultNote,
+        graph_scope: zoneDocumentPaths,
         cards: [
             { id: "source-total", label: "Source Files", metric: "source_total", format: "number" },
-            { id: "summarized", label: "Summarized", metric: "source_covered", denominator_metric: "source_total", format: "fraction" },
-            { id: "to-summarize", label: "To Summarize", metric: "to_summarize", format: "number" },
-            { id: "compiled", label: "Compiled", metric: "compiled", denominator_metric: "summarized", format: "fraction" },
-            { id: "entities", label: "Entities", metric: "entities", format: "number" },
-            { id: "claims", label: "Claims", metric: "claims", format: "number" },
+            { id: "stage-total", label: "Stages", metric: "stage_total", format: "number" },
+            { id: "completed-stages", label: "Completed", metric: "completed_stages", denominator_metric: "stage_total", format: "fraction" },
         ],
         sections: [
             { id: "status", type: "status", title: "Compile Status", path: ".interf/runtime/health.json" },
             { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
-            { id: "graph", type: "graph", title: "Knowledge Graph", paths: ["summaries", "knowledge"] },
-            { id: "core-docs", type: "documents", title: "Core Docs", paths: ["home.md", "knowledge/indexes", "knowledge/entities", "knowledge/claims", "summaries"] },
-            { id: "claims", type: "table", title: "Claims", path: "knowledge/claims" },
+            ...(zoneDocumentPaths.length > 0
+                ? [{ id: "outputs", type: "documents", title: "Compiled Outputs", paths: zoneDocumentPaths }]
+                : []),
+            { id: "workflow", type: "documents", title: "Workflow Docs", paths: ["workflow/README.md", ...workflow.stages.map((stage) => `workflow/compile/stages/${stage.skillDir}`)] },
         ],
     };
 }
-function normalizeWorkspaceCards(cards, defaults) {
-    if (!Array.isArray(cards) || cards.length === 0) {
-        return defaults;
-    }
-    return cards.map((card) => {
-        const matchingDefault = defaults.find((candidate) => candidate.id === card.id);
-        const normalized = {
-            ...(matchingDefault ?? {}),
-            ...card,
-        };
-        if (normalized.format === "fraction" &&
-            typeof normalized.denominator_metric !== "string") {
-            if (normalized.metric === "compiled") {
-                normalized.denominator_metric = "summarized";
-            }
-            else if (normalized.metric === "source_covered") {
-                normalized.denominator_metric = "source_total";
-            }
-        }
-        return normalized;
-    });
-}