@interf/compiler 0.5.0 → 0.6.1

package/dist/lib/state-health.js

@@ -7,7 +7,7 @@ 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, resolveCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
 import { listFilesRecursive } from "./filesystem.js";
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = join(compiledPath, zonePath);
@@ -26,7 +26,9 @@ export function computeCompiledHealth(dirPath) {
     const state = loadState(dirPath);
     const validation = validateCompiled(dirPath);
     const activeRun = loadRuntimeRun(dirPath);
-    const workflowId = config ? resolveCompiledWorkflowFromConfig(config) : null;
+    const workflowId = config
+        ? resolveRequiredCompiledWorkflowFromConfig(config, `.interf/interf.json for ${dirPath}`)
+        : null;
     let workflow = null;
     if (workflowId) {
         try {

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 { CompiledHealthSchema, CompiledInventorySchema, CompiledRawSnapshotSchema, CompiledStateSchema, CompiledViewSpecSchema, } from "./schema.js";
-import { compiledInventoryEntryCount, compiledInventoryTotal, emptyCompiledInventory, } from "./runtime-inventory.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 { compiledRuntimeInventoryPath, compiledRuntimeRoot, } from "./compiled-paths.js";
-const NORMALIZABLE_RUNTIME_TIMESTAMP_FIELDS = [
-    "last_add",
-    "last_summarize",
-    "last_structure",
-    "last_shape",
-    "last_compile",
-];
 export function loadState(dirPath) {
     const path = statePath(dirPath);
     if (!existsSync(path))
@@ -21,18 +14,8 @@ export function loadState(dirPath) {
         return null;
     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;
 }
@@ -81,97 +64,6 @@ export function initCompiledState() {
         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 = CompiledStateSchema.safeParse(normalized);
-    return parsed.success ? parsed.data : null;
-}
-function healParsedRuntimeState(dirPath, state) {
-    const hasLegacyStageFields = (typeof state.last_summarize === "string" && state.last_summarize.length > 0) ||
-        (typeof state.last_structure === "string" && state.last_structure.length > 0) ||
-        (typeof state.last_shape === "string" && state.last_shape.length > 0);
-    const hasStageMap = Boolean(state.stages) &&
-        typeof state.stages === "object" &&
-        Object.keys(state.stages ?? {}).length > 0;
-    if (state.version >= 2 && (hasStageMap || !hasLegacyStageFields))
-        return null;
-    const next = {
-        ...initCompiledState(),
-        ...state,
-        stages: { ...(state.stages ?? {}) },
-    };
-    if (typeof state.last_summarize === "string" && state.last_summarize.length > 0) {
-        next.stages.summarize = {
-            contract_type: "compiled-file-evidence",
-            status: "succeeded",
-            finished_at: state.last_summarize,
-            counts: {
-                summarized: state.summarized ?? 0,
-                expected_summary_total: state.summarized ?? 0,
-            },
-            zone_counts: {
-                summaries: state.summarized ?? 0,
-            },
-        };
-    }
-    if (typeof state.last_structure === "string" && state.last_structure.length > 0) {
-        next.stages.structure = {
-            contract_type: "compiled-knowledge-structure",
-            status: "succeeded",
-            finished_at: state.last_structure,
-            counts: {
-                summary_total: state.structured ?? state.summarized ?? 0,
-            },
-        };
-    }
-    if (typeof state.last_shape === "string" && state.last_shape.length > 0) {
-        next.stages.shape = {
-            contract_type: "compiled-query-shape",
-            status: "succeeded",
-            finished_at: state.last_shape,
-            counts: {
-                summary_total: state.shaped ?? state.summarized ?? 0,
-            },
-        };
-    }
-    const inventoryPath = compiledRuntimeInventoryPath(dirPath);
-    if (existsSync(inventoryPath)) {
-        const inventory = readJsonFileWithSchema(inventoryPath, "compiled inventory", CompiledInventorySchema);
-        const inventoryTotal = compiledInventoryTotal(inventory);
-        if (inventory &&
-            inventoryTotal === (state.summarized ?? 0) &&
-            compiledInventoryEntryCount(inventory) === (state.summarized ?? 0)) {
-            next.inventory_complete = true;
-        }
-    }
-    return next;
-}
-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-view.js

@@ -6,7 +6,7 @@ import { loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { rawSnapshotPath } from "./state-paths.js";
 import { compiledRuntimeRoot, workflowPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig } from "./workflow-definitions.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig } from "./workflow-definitions.js";
 export function ensureCompiledViewSpec(dirPath) {
     const existing = loadCompiledViewSpec(dirPath);
     const now = new Date().toISOString();
@@ -70,13 +70,13 @@ export function normalizeCompiledViewSpec(existing, defaults) {
 }
 function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     const config = readInterfConfig(dirPath);
-    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    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")
+    const outputDocumentPaths = (schema?.zones ?? [])
+        .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
         .map((zone) => zone.path);
-    const defaultNote = (schema?.zones ?? []).find((zone) => zone.kind === "file")?.path ?? null;
+    const defaultNote = (schema?.zones ?? []).find((zone) => zone.role === "output" && zone.kind === "file")?.path ?? null;
     return {
         kind: "compiled-view-spec",
         version: 2,
@@ -85,7 +85,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
         health_source: ".interf/runtime/health.json",
         state_source: ".interf/runtime/state.json",
         default_note: defaultNote,
-        graph_scope: zoneDocumentPaths,
+        graph_scope: outputDocumentPaths,
         cards: [
             { id: "source-total", label: "Source Files", metric: "source_total", format: "number" },
             { id: "stage-total", label: "Stages", metric: "stage_total", format: "number" },
@@ -94,8 +94,8 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
         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" },
-            ...(zoneDocumentPaths.length > 0
-                ? [{ id: "outputs", type: "documents", title: "Compiled Outputs", paths: zoneDocumentPaths }]
+            ...(outputDocumentPaths.length > 0
+                ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
                 : []),
             { id: "workflow", type: "documents", title: "Workflow Docs", paths: ["workflow/README.md", ...workflow.stages.map((stage) => `workflow/compile/stages/${stage.skillDir}`)] },
         ],

package/dist/lib/state.d.ts

@@ -4,3 +4,4 @@ export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompi
 export { refreshCompiledArtifacts, } from "./state-artifacts.js";
 export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
 export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+export declare function initializeCompiledRuntimeState(dirPath: string): void;

package/dist/lib/state.js

@@ -3,3 +3,10 @@ export { loadState, saveState, loadCompiledHealth, saveCompiledHealth, loadCompi
 export { refreshCompiledArtifacts, } from "./state-artifacts.js";
 export { computeCompiledHealth, resolveCompiledStatus, resolveCompiledStage, } from "./state-health.js";
 export { ensureCompiledViewSpec, ensureCompiledRawSnapshot, normalizeCompiledViewSpec, } from "./state-view.js";
+import { saveEmptyCompiledInventory, initCompiledState, saveState } from "./state-io.js";
+import { refreshCompiledArtifacts } from "./state-artifacts.js";
+export function initializeCompiledRuntimeState(dirPath) {
+    saveState(dirPath, initCompiledState());
+    saveEmptyCompiledInventory(dirPath);
+    refreshCompiledArtifacts(dirPath, { ensureViewSpec: true });
+}

package/dist/lib/test-execution.js

@@ -203,7 +203,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Answer the truth-check question the same way you would answer a real user inside this compiled dataset.",
             "Prefer the workflow-declared compiled outputs before raw fallback.",
             "This sandbox is self-contained: the copied compiled dataset has its own sanitized `raw/` fallback via `.interf/interf.json` `source.path`.",
-            "The project control plane is intentionally absent from this sandbox. Work only from this sandboxed compiled dataset and its embedded raw files.",
+            "The original project root is intentionally absent from this sandbox. Work only from this sandboxed compiled dataset and its embedded raw files.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated raw test shell.",
@@ -211,7 +211,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Use the local native `interf-query` skill available in this shell.",
             "There is no compiled dataset in this sandbox.",
             "Answer only from `raw/` inside this shell.",
-            "The project control plane is intentionally absent from this sandbox.",
+            "The original project root is intentionally absent from this sandbox.",
         ];
     return [
         ...header,

package/dist/lib/test-paths.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
@@ -9,11 +9,17 @@ export function testSpecRootPath(sourcePath) {
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
+function isDatasetTestsRootPath(artifactRootPath) {
+    return basename(dirname(artifactRootPath)) === "tests";
+}
 export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
-    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "runs");
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
 }
 export function targetTestRunGitignorePath(compiledPath, type) {
     return join(targetTestRunsPath(compiledPath, type), ".gitignore");
@@ -22,7 +28,10 @@ export function targetTestSandboxesPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
-    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
 }
 export function targetTestSandboxGitignorePath(compiledPath, type) {
     return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");

package/dist/lib/test-sandbox.js

@@ -2,10 +2,10 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
-import { readInterfConfig, resolveSourceControlPath, resolveCompiledRawPath } from "./interf.js";
+import { readInterfConfig, resolveCompiledRawPath } from "./interf.js";
 import { projectRawTestQueryShell } from "./agent-shells.js";
 import { compiledCompiledPathForDataset } from "./project-paths.js";
-import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { saveCompiledInterfConfig } from "./source-config.js";
 import { refreshCompiledArtifacts } from "./state.js";
 import { projectRawSnapshot } from "./compiled-raw.js";
 import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
@@ -46,27 +46,14 @@ export function createTestSandbox(target) {
                 throw new Error(`Sandbox compiled is missing interf.json: ${sandboxTargetPath()}`);
             }
             if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                const projectPath = resolveSourceControlPath(target.path);
-                const projectConfig = loadSourceFolderConfig(projectPath);
-                const datasetConfig = findSourceDatasetConfig(projectConfig, sandboxConfig.name);
-                if (!datasetConfig) {
-                    throw new Error(`Sandbox compiled is missing a trusted dataset binding for "${sandboxConfig.name}": ${target.path}`);
-                }
-                const controlSourcePath = resolveSourceDatasetPath(projectPath, datasetConfig);
-                projectRawSnapshot({
-                    sourcePath: controlSourcePath,
-                    destinationPath: sandboxRawPath(),
-                    compiledPath: target.path,
-                    mode: "link-or-copy",
-                    prune: false,
-                    preserveTimestamps: false,
-                });
+                throw new Error(`Sandbox compiled is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled dataset before testing it.`);
             }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());

package/dist/lib/test-specs.js

@@ -21,7 +21,7 @@ function serializeTestSpec(spec) {
         type: spec.type,
         name: spec.name,
         ...(spec.description ? { description: spec.description } : {}),
-        checks: spec.cases.map((testCase) => ({
+        cases: spec.cases.map((testCase) => ({
             id: testCase.id,
             question: testCase.question,
             ...(testCase.file ? { file: testCase.file } : {}),

package/dist/lib/validate-compiled.js

@@ -1,14 +1,17 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { discoverSourceFiles } from "./discovery.js";
-import { compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
+import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } 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 { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
 import { listFilesRecursive } from "./filesystem.js";
+function workflowSchemaPresent(dirPath) {
+    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
+}
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
     if (!existsSync(absolutePath))
@@ -19,7 +22,9 @@ function countZoneArtifacts(compiledPath, zonePath, kind) {
 }
 function readWorkflowContext(dirPath) {
     const config = readCompiledConfig(dirPath);
-    const workflowId = config.valid ? resolveCompiledWorkflowFromConfig(config.value) : null;
+    const workflowId = config.valid
+        ? resolveRequiredCompiledWorkflowFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
+        : null;
     let workflow = null;
     if (workflowId) {
         try {
@@ -82,7 +87,7 @@ export function validateCompiled(dirPath) {
         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_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
 }
@@ -94,7 +99,7 @@ export function validateCompiledStage(dirPath, stageId) {
         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_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     const errors = [];
@@ -109,9 +114,9 @@ export function validateCompiledStage(dirPath, stageId) {
     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.");
+        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
     else if (!checks.schema_valid)
-        errors.push("Could not parse .interf/workflow/compiled.schema.json.");
+        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
     const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
     checks.stage_present = workflowStage !== null;
     if (!checks.stage_present) {
@@ -176,7 +181,7 @@ export function validateCompiledWorkflow(dirPath) {
         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_present: workflowSchemaPresent(dirPath),
         schema_valid: context.schema !== null,
     };
     if (!context.workflow) {

package/dist/lib/validate.d.ts

@@ -5,7 +5,9 @@ export declare function readCompiledConfig(dirPath: string): {
     value: ReturnType<typeof readInterfConfig>;
     typeMatch(): boolean;
 };
-export declare function validateSynthFiles(files: string[]): {
+export declare function validateSynthFiles(files: string[], options?: {
+    requiredFrontmatterKeys?: string[];
+}): {
     invalid_frontmatter: number;
     short_abstracts: number;
 };
@@ -13,5 +15,7 @@ export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoot
 export declare function asNumber(value: unknown): number;
 export declare function isOutputMarkdownFile(filePath: string): boolean;
 export declare function safeReadText(filePath: string): string | null;
+export declare function extractSynthAbstract(frontmatter: Record<string, unknown>, body: string): string | null;
+export declare function countSynthAbstractWords(frontmatter: Record<string, unknown>, body: string): number;
 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

@@ -7,12 +7,6 @@ import { listFilesRecursive } from "./filesystem.js";
 import { readInterfConfig } from "./interf.js";
 import { parseJsonFrontmatter } from "./parse.js";
 import { compiledInterfConfigPath } from "./compiled-paths.js";
-const REQUIRED_DIGEST_FIELDS = [
-    "source_kind",
-    "evidence_tier",
-    "truth_mode",
-    "state",
-];
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
 export function readCompiledConfig(dirPath) {
@@ -36,7 +30,7 @@ export function readCompiledConfig(dirPath) {
         },
     };
 }
-export function validateSynthFiles(files) {
+export function validateSynthFiles(files, options) {
     let invalidFrontmatter = 0;
     let shortAbstracts = 0;
     for (const filePath of files) {
@@ -44,11 +38,11 @@ export function validateSynthFiles(files) {
         if (content === null)
             continue;
         const parsed = parseJsonFrontmatter(content);
-        if (!parsed || !hasRequiredSynthFields(parsed.frontmatter)) {
+        if (!parsed || !hasRequiredFrontmatterKeys(parsed.frontmatter, options?.requiredFrontmatterKeys)) {
             invalidFrontmatter += 1;
             continue;
         }
-        const abstractWords = countAbstractWords(parsed.frontmatter, parsed.body);
+        const abstractWords = countSynthAbstractWords(parsed.frontmatter, parsed.body);
         if (abstractWords < MIN_ABSTRACT_WORDS) {
             shortAbstracts += 1;
         }
@@ -138,22 +132,36 @@ function dedupeFiles(dirPaths) {
     }
     return files;
 }
-function hasRequiredSynthFields(frontmatter) {
-    const hasSourceReference = "source" in frontmatter || "source_file" in frontmatter || "raw" in frontmatter;
-    return hasSourceReference && REQUIRED_DIGEST_FIELDS.every((field) => field in frontmatter);
+function hasRequiredFrontmatterKeys(frontmatter, requiredKeys) {
+    return (requiredKeys ?? []).every((field) => field in frontmatter);
 }
-function countAbstractWords(frontmatter, body) {
-    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract : null;
-    if (frontmatterAbstract && frontmatterAbstract.trim().length > 0) {
-        return countWords(frontmatterAbstract);
+function extractBodyAbstract(body) {
+    const lines = body.split(/\r?\n/);
+    const abstractHeadingIndex = lines.findIndex((line) => /^#{1,2}\s+Abstract\s*$/.test(line.trim()));
+    if (abstractHeadingIndex < 0)
+        return null;
+    const abstractLines = [];
+    for (let index = abstractHeadingIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (/^#{1,2}\s+\S/.test(line.trim()))
+            break;
+        abstractLines.push(line);
     }
-    const match = body.match(/^## Abstract\s+([\s\S]*?)(?:\n## |\n# |$)/m);
-    if (!match)
-        return 0;
-    const abstractText = match[1];
-    if (!abstractText)
+    const abstractText = abstractLines.join("\n").trim();
+    return abstractText.length > 0 ? abstractText : null;
+}
+export function extractSynthAbstract(frontmatter, body) {
+    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract.trim() : "";
+    if (frontmatterAbstract.length > 0) {
+        return frontmatterAbstract;
+    }
+    return extractBodyAbstract(body);
+}
+export function countSynthAbstractWords(frontmatter, body) {
+    const abstract = extractSynthAbstract(frontmatter, body);
+    if (!abstract)
         return 0;
-    return countWords(abstractText);
+    return countWords(abstract);
 }
 function countWords(text) {
     return text

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

@@ -0,0 +1,26 @@
+import type { WorkflowExecutor } from "./executors.js";
+import { validateWorkflowPackage } from "./local-workflows.js";
+import type { SourceTruthCheck } from "./schema.js";
+import { type WorkflowReporter } from "./workflows.js";
+export interface WorkflowAuthoringRunResult {
+    status: "updated" | "no-change" | "invalid" | "executor-failed";
+    changed: boolean;
+    summary: string;
+    validation: ReturnType<typeof validateWorkflowPackage> | null;
+    workflowPath: string;
+    shellPath: string;
+}
+export declare function runWorkflowAuthoringDraft(options: {
+    sourcePath: string;
+    datasetPath: string;
+    baseWorkflowId: string;
+    workflowId: string;
+    label: string;
+    hint: string;
+    taskPrompt: string;
+    checks?: SourceTruthCheck[];
+    executor: WorkflowExecutor;
+    preparePreview?: boolean;
+    previewReporter?: WorkflowReporter | null;
+}): Promise<WorkflowAuthoringRunResult>;
+export declare function resolveWorkflowDraftPath(sourcePath: string, workflowId: string): string;