@interf/compiler 0.5.1 → 0.6.3

package/builtin-workflows/interf/workflow.json

@@ -5,8 +5,12 @@
     "kind": "compiled",
     "version": 1
   },
-  "label": "Interf Compiler (Recommended)",
-  "hint": "Interf Compiler's default methodology: summarize source-grounded evidence, structure the cross-file layer, then shape the final compiled dataset around its focus and saved truth checks.",
+  "purpose": {
+    "label": "General compiled context workflow for agent use",
+    "task_hint": "Compile mixed raw files into evidence-backed summaries, cross-file structure, and a usable entrypoint for agents answering the questions this task depends on."
+  },
+  "label": "Interf (Built-in)",
+  "hint": "Interf's built-in workflow: summarize source-grounded evidence, structure the cross-file layer, then shape the final context folder around its task focus and checks.",
   "stages": [
     {
       "id": "summarize",
@@ -31,6 +35,15 @@
         "markdown_frontmatter_valid_zones": [
           "summaries"
         ],
+        "frontmatter_required_keys_in_zones": {
+          "summaries": [
+            "source",
+            "source_kind",
+            "evidence_tier",
+            "truth_mode",
+            "state"
+          ]
+        },
         "markdown_abstract_valid_zones": [
           "summaries"
         ]
@@ -69,7 +82,7 @@
     {
       "id": "shape",
       "label": "Shape",
-      "description": "Shape the final compiled dataset around the saved focus and truth checks.",
+      "description": "Shape the final context folder around the saved task focus and checks.",
       "contract_type": "compiled-query-shape",
       "skill_dir": "shape",
       "reads": [
@@ -118,11 +131,12 @@
       "Use taxonomy and ontology only as means to improve retrieval, navigation, and evidence tracking.",
       "For small datasets, prefer a minimal stable substrate over exhaustive graph sprawl.",
       "When you add wikilinks, target real compiled notes by exact basename or explicit relative path. Do not invent title-style links unless that exact title is also a declared note label or alias.",
+      "Do not add wikilinks in structure outputs to files that the shape stage creates later. If a route belongs in `home.md` or a later shaped note, leave plain text now and let the later stage add the link.",
       "For summary references, prefer explicit links like `[[summaries/<file-stem>]]` or plain code paths. For knowledge notes, prefer the final filename stem under `knowledge/`."
     ],
     "shape": [
-      "Use the dataset focus and saved truth checks to bias the final compiled dataset toward the job it should be especially good at.",
-      "Do not copy expected answers into the final compiled dataset just because the checks imply them.",
+      "Use the saved task focus and checks to bias the final context folder toward the job it should be especially good at.",
+      "Do not copy expected answers into the final context folder just because the checks imply them.",
       "If a saved truth check depends on chart-derived or table-derived values, verify the needed evidence in `raw/` while shaping and write focused notes that preserve bounded values plus provenance.",
       "Prefer better routing, prioritization, and focused navigation over speculative synthesis.",
       "Any wikilinks you add to `home.md` or indexes must resolve to real compiled note basenames or explicit relative paths."

package/builtin-workflows/interf/{compiled.schema.json → workflow.schema.json}

@@ -1,11 +1,12 @@
 {
-  "kind": "compiled-schema",
+  "kind": "workflow-schema",
   "version": 1,
   "target_type": "compiled",
-  "label": "Interf Compiler (Recommended) compiled dataset schema",
+  "label": "Interf built-in workflow schema",
   "zones": [
     {
       "id": "raw",
+      "role": "input",
       "path": "raw",
       "kind": "directory",
       "required": true,
@@ -14,6 +15,7 @@
     },
     {
       "id": "summaries",
+      "role": "working",
       "path": "summaries",
       "kind": "directory",
       "required": true,
@@ -24,6 +26,7 @@
     },
     {
       "id": "knowledge-entities",
+      "role": "output",
       "path": "knowledge/entities",
       "kind": "directory",
       "required": true,
@@ -34,6 +37,7 @@
     },
     {
       "id": "knowledge-claims",
+      "role": "output",
       "path": "knowledge/claims",
       "kind": "directory",
       "required": true,
@@ -44,6 +48,7 @@
     },
     {
       "id": "knowledge-indexes",
+      "role": "output",
       "path": "knowledge/indexes",
       "kind": "directory",
       "required": true,
@@ -55,16 +60,18 @@
     },
     {
       "id": "home",
+      "role": "output",
       "path": "home.md",
       "kind": "file",
       "required": true,
       "owned_by": [
         "shape"
       ],
-      "description": "Primary entrypoint note for agents using the compiled dataset."
+      "description": "Primary entrypoint note for agents using the context folder."
     },
     {
       "id": "runtime",
+      "role": "runtime",
       "path": ".interf/runtime",
       "kind": "runtime",
       "required": true,

package/dist/bin.js

@@ -1,29 +1,3 @@
 #!/usr/bin/env node
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { initCommand } from "./commands/init.js";
-import { createCommand } from "./commands/create.js";
-import { compileCommand } from "./commands/compile.js";
-import { testCommand } from "./commands/test.js";
-import { doctorCommand } from "./commands/doctor.js";
-import { listCommand } from "./commands/list.js";
-import { statusCommand } from "./commands/status.js";
-import { resetCommand } from "./commands/reset.js";
-import { defaultCommand } from "./commands/default.js";
-import { verifyCommand } from "./commands/verify.js";
-yargs(hideBin(process.argv))
-    .scriptName("interf")
-    .command(defaultCommand)
-    .command(initCommand)
-    .command(compileCommand)
-    .command(testCommand)
-    .command(createCommand)
-    .command(doctorCommand)
-    .command(listCommand)
-    .command(statusCommand)
-    .command(verifyCommand)
-    .command(resetCommand)
-    .strict()
-    .help()
-    .version()
-    .parse();
+import { runCli } from "./cli/index.js";
+await runCli();

package/dist/{commands → cli/commands}/check-draft.d.ts

@@ -1,5 +1,5 @@
-import type { WorkflowExecutor } from "../lib/executors.js";
-import type { SourceTruthCheck } from "../lib/schema.js";
+import type { WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { SourceTruthCheck } from "../../packages/project-model/lib/schema.js";
 export declare function buildTruthCheckDraftPrompt(options: {
     datasetName: string;
     datasetPath: string;

package/dist/{commands → cli/commands}/check-draft.js

@@ -12,27 +12,27 @@ export function buildTruthCheckDraftPrompt(options) {
     const taskLines = normalizedAbout
         ? [
             `Primary task: ${normalizedAbout}`,
-            "Draft checks that directly measure whether a local agent would be accurate on that task.",
+            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that task.",
             "Prefer checks that would make a human confident the dataset is useful for that exact job.",
         ]
         : [
             "No primary task was provided.",
-            "Prefer broad, representative checks that reflect the most useful questions this dataset should answer.",
+            "Prefer broad, representative checks that reflect the most useful questions a human would verify from this source folder.",
         ];
     return [
-        "You are drafting Interf truth checks for a local dataset.",
+        "You are drafting Interf checks for a local source folder.",
         "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
         "Do not ask follow-up questions.",
-        "Keep the checks concrete, explicit, and useful for measuring agent accuracy on this dataset.",
+        "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the files in this source folder.",
         "",
-        `Dataset id: ${options.datasetName}`,
-        `Dataset folder: ${options.datasetPath}`,
+        `Setup id: ${options.datasetName}`,
+        `Source folder: ${options.datasetPath}`,
         ...taskLines,
         "",
         `Write exactly one JSON array to ${JSON.stringify(options.outputPath)}.`,
-        `Draft ${options.targetCount} checks unless the dataset is too small; in that case write fewer.`,
+        `Draft ${options.targetCount} checks unless the source folder is too small; in that case write fewer.`,
         "Each array item must be an object with exactly these keys:",
-        '- "question": a plain-English question answerable from this dataset',
+        '- "question": a plain-English question answerable from this source folder',
         '- "answer": the expected correct answer in plain English',
         "",
         "Quality bar:",
@@ -72,8 +72,8 @@ export async function draftTruthChecks(options) {
             return {
                 checks: null,
                 error: code === 0
-                    ? "The local agent finished without writing draft truth checks."
-                    : "The local agent did not produce draft truth checks.",
+                    ? "The local agent finished without writing draft checks."
+                    : "The local agent did not produce draft checks.",
             };
         }
         let parsed;
@@ -83,15 +83,15 @@ export async function draftTruthChecks(options) {
         catch (error) {
             return {
                 checks: null,
-                error: `Draft truth checks were not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+                error: `Draft checks were not valid JSON: ${error instanceof Error ? error.message : String(error)}`,
             };
         }
         const validated = DraftTruthChecksSchema.safeParse(parsed);
         if (!validated.success) {
-            const detail = validated.error.issues[0]?.message ?? "invalid draft truth checks";
+            const detail = validated.error.issues[0]?.message ?? "invalid draft checks";
             return {
                 checks: null,
-                error: `Draft truth checks did not match the required shape: ${detail}`,
+                error: `Draft checks did not match the required shape: ${detail}`,
             };
         }
         return {

package/dist/{commands → cli/commands}/compile-controller.d.ts

@@ -1,6 +1,6 @@
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../lib/executors.js";
-import type { SourceDatasetConfig } from "../lib/schema.js";
-import type { StageShellRetentionMode } from "../lib/workflows.js";
+import type { WorkflowExecutionProfile, WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { StageShellRetentionMode } from "../../packages/compiler/workflows.js";
 export declare function runConfiguredCompiledCompile(options: {
     executor: WorkflowExecutor;
     testExecutor?: WorkflowExecutor | null;

package/dist/{commands → cli/commands}/compile-controller.js

@@ -2,13 +2,14 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
-import { readInterfConfig } from "../lib/interf.js";
-import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
-import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
-import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
-import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
-import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
-import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
+import { readInterfConfig } from "../../packages/project-model/interf.js";
+import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../../packages/project-model/compiled-reset.js";
+import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../../packages/workflow-package/workflow-definitions.js";
+import { loadCompiledDatasetConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { runWorkflowImprovementLoop } from "../../packages/workflow-authoring/workflow-improvement.js";
+import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../../packages/project-model/compiled-paths.js";
+import { readCompiledSchemaFile } from "../../packages/compiler/compiled-schema.js";
+import { initializeCompiledRuntimeState } from "../../packages/compiler/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
 import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
@@ -19,14 +20,6 @@ function printCompileFailure(compiledPath, failedStage) {
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
-const BEST_VARIATION_RUNTIME_RESTORE_PATHS = [
-    ".interf/runtime/state.json",
-    ".interf/runtime/health.json",
-    ".interf/runtime/view-spec.json",
-    ".interf/runtime/inventory.json",
-    ".interf/runtime/run.json",
-    ".interf/runtime/raw-snapshot.json",
-];
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
@@ -39,10 +32,8 @@ function bestVariationRestorePaths(compiledPath) {
         ".codex",
         ".agents",
         ".cursor",
-        ".obsidian",
         ".interf/interf.json",
         ".interf/workflow",
-        ...BEST_VARIATION_RUNTIME_RESTORE_PATHS,
         ...zonePaths,
     ];
 }
@@ -71,6 +62,8 @@ function restoreCompiledBestState(snapshotPath, compiledPath) {
         rmSync(join(compiledPath, relativePath), { recursive: true, force: true });
         copyRelativePathIfPresent(snapshotPath, compiledPath, relativePath);
     }
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
 }
 async function runWorkflowVariation(options) {
     let bestOutcome = null;
@@ -85,16 +78,16 @@ async function runWorkflowVariation(options) {
                 const resetTarget = attempt > 1
                     ? `attempt ${attempt}/${options.maxAttempts}`
                     : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated compiled state before ${resetTarget}...`));
+                console.log(chalk.dim(`  Resetting generated compiled-context state before ${resetTarget}...`));
                 resetCompiledGeneratedState(options.compiledPath, "compile");
             }
             const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building compiled dataset (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building compiled dataset (${options.variationLabel})...`,
+                    ? `Building compiled context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building compiled context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Compiled dataset ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Compiled dataset ready for ${options.variationLabel}.`,
+                    ? `Compiled context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Compiled context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
             });
             if (!result.ok) {
@@ -130,7 +123,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved compiled-dataset test after compile.",
+                    fatalError: "Could not run the saved compiled-context check after compile.",
                 };
             }
             console.log();
@@ -145,7 +138,7 @@ async function runWorkflowVariation(options) {
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Compiled passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                console.log(chalk.green(`  Compiled context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
                 printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
@@ -188,9 +181,9 @@ function summarizeWorkflowVariation(options) {
     const passedQuestions = options.result.bestOutcome?.result.passedCases ?? 0;
     const totalQuestions = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalQuestions;
     const summary = options.result.passed
-        ? `Passed ${passedQuestions}/${totalQuestions} truth checks.`
+        ? `Passed ${passedQuestions}/${totalQuestions} checks.`
         : options.result.bestOutcome
-            ? `Best result: ${passedQuestions}/${totalQuestions} truth checks passed.`
+            ? `Best result: ${passedQuestions}/${totalQuestions} checks passed.`
             : options.result.failedStage
                 ? `Compile failed at stage ${options.result.failedStage} before any test result.`
                 : "Workflow variation did not produce a passing result.";
@@ -220,16 +213,16 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
     }
 }
 function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Compiled dataset: ${options.compiledPath}`));
+    console.log(chalk.dim(`  Context folder: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add truth checks, then `interf test`."));
+        console.log(chalk.dim("  Next: run `interf` to add checks, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the compiled dataset or rerun `interf test` for a fresh comparison."));
+        console.log(chalk.dim("  Next: inspect the compiled context, or run `interf test` if you also want a raw-versus-compiled-context comparison."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to compare the raw files and the compiled dataset."));
+    console.log(chalk.dim("  Next: run `interf test` to compare the raw files and the compiled context."));
 }
 function formatVariationQuestionSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -240,7 +233,7 @@ function printWorkflowVariationSummary(summaries) {
     console.log();
     console.log(chalk.bold("  Workflow variation summary"));
     console.log();
-    console.log("  | Variation | Kind | Truth checks | Result |");
+    console.log("  | Variation | Kind | Checks | Result |");
     console.log("  | --- | --- | --- | --- |");
     for (const summary of summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
@@ -252,7 +245,7 @@ function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
     console.log();
     console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForCompiled(compiledPath)}`));
     console.log(chalk.dim("  The project-level workflow selection was not changed automatically."));
-    console.log(chalk.dim("  Recompiling this existing compiled dataset reuses that local workflow draft."));
+    console.log(chalk.dim("  Recompiling this existing compiled context reuses that local workflow draft."));
 }
 export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
@@ -262,19 +255,19 @@ export async function runConfiguredCompiledCompile(options) {
     const loopEnabled = maxAttempts != null;
     const checks = options.compiledConfig?.checks ?? [];
     if (loopEnabled && checks.length === 0) {
-        console.log(chalk.yellow("  Retry and self-improving modes need saved truth checks. Building once without those loops."));
+        console.log(chalk.yellow("  Retry and self-improving modes need checks. Building once without those loops."));
     }
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same workflow variation, test the compiled context, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
         }
         if (maxLoops != null) {
             console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
-            console.log(chalk.dim("  Interf Compiler will review failed runs, edit the workflow package, and test new workflow variations."));
+            console.log(chalk.dim("  Interf will review failed runs, edit the workflow, and test new workflow variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
@@ -302,11 +295,13 @@ export async function runConfiguredCompiledCompile(options) {
     const previousVariations = [];
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
-        const compiledConfig = options.compiledConfig ?? {
-            name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-            path: ".",
-            checks: [],
-        };
+        const compiledConfig = options.compiledConfig
+            ?? loadCompiledDatasetConfig(options.compiledPath)
+            ?? {
+                name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
+                path: "./dataset",
+                checks: [],
+            };
         const adoptVariationBest = (variation, result) => {
             if (result.bestOutcome && result.bestSnapshotPath && (!bestOutcome || testScore(result.bestOutcome) > testScore(bestOutcome))) {
                 if (bestSnapshotPath) {
@@ -419,20 +414,20 @@ export async function runConfiguredCompiledCompile(options) {
         if (bestSnapshotPath && bestVariation > 0) {
             restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing compiled dataset from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing compiled context from variation ${bestVariation}, attempt ${bestAttempt}.`));
         }
         process.exitCode = 1;
         console.log();
         printWorkflowVariationSummary(previousVariations);
         printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
         if (maxLoops != null) {
-            console.log(chalk.red(`  Compiled did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Compiled context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }
         else {
-            console.log(chalk.red(`  Compiled did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Compiled context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt truth-check pass rate: ${questionPassRate(bestOutcome)}%.`));
+            console.log(chalk.dim(`  Best attempt check pass rate: ${questionPassRate(bestOutcome)}%.`));
         }
         printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;

package/dist/cli/commands/compile.d.ts

@@ -0,0 +1,33 @@
+import * as p from "@clack/prompts";
+import { detectInterf } from "../../packages/project-model/interf.js";
+import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { CommandModule } from "yargs";
+import { chooseCompiledConfigToBuild, ensureCompiledFromConfig } from "./compiled-flow.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runConfiguredCompiledCompile } from "./compile-controller.js";
+export { runConfiguredCompiledCompile } from "./compile-controller.js";
+export declare const compileCommand: CommandModule;
+interface CompileCommandDeps {
+    chooseCompiledConfigToBuild: typeof chooseCompiledConfigToBuild;
+    confirm: typeof p.confirm;
+    detectInterf: typeof detectInterf;
+    ensureCompiledFromConfig: typeof ensureCompiledFromConfig;
+    resolveInteractiveCompileLoopOverrides: typeof resolveInteractiveCompileLoopOverrides;
+    resolveOrConfigureLocalExecutor: typeof resolveOrConfigureLocalExecutor;
+    runConfiguredCompiledCompile: typeof runConfiguredCompiledCompile;
+}
+export interface CompileCommandResult {
+    compiledPath: string;
+    testedDuringCompile: boolean;
+}
+export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
+export declare function resolveInteractiveCompileLoopOverrides(options: {
+    compiledPath: string;
+    compiledConfig: SourceDatasetConfig | null;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+}): Promise<{
+    compiledConfig: SourceDatasetConfig | null;
+    maxAttemptsOverride: number | null;
+    maxLoopsOverride: number | null;
+} | null>;