@interf/compiler 0.5.0 → 0.6.1

package/dist/commands/init.js

@@ -1,13 +1,13 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
+import { resolve } from "node:path";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { SOURCE_FOLDER_CONFIG_FILE, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
+import { SOURCE_FOLDER_CONFIG_FILE, syncCompiledInterfConfigFromSourceDatasetConfig, upsertSourceDatasetConfig, } from "../lib/source-config.js";
 import { DEFAULT_COMPILED_NAME, describeCompileLoopSelection, promptSingleCompiledConfig, } from "./source-config-wizard.js";
 import { buildCompiledWorkflowOptions, chooseCompiledWorkflow, createWorkflowWizard, } from "./create-workflow-wizard.js";
-import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { findBuiltCompiledPath, findSavedCompiledConfig, listSavedCompiledEntries, } from "./compiled-flow.js";
 import { readSavedTestComparison } from "./test-flow.js";
-import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
-import { runConfiguredCompiledCompile } from "./compile.js";
+import { runCompileCommand } from "./compile.js";
 import { runTestCommand } from "./test.js";
 function describeSavedQuestions(dataset) {
     const count = dataset.checks.length;
@@ -15,19 +15,13 @@ function describeSavedQuestions(dataset) {
         return "No saved truth checks yet";
     return `${count} saved truth check${count === 1 ? "" : "s"}`;
 }
-function compileModeAlreadyRanSavedTests(dataset) {
-    if (dataset.checks.length === 0)
-        return false;
-    return (resolveDatasetCompileMaxAttempts(dataset) != null ||
-        resolveDatasetCompileMaxLoops(dataset) != null);
-}
 function printDatasetSummary(options) {
     const compiledConfig = options.builtCompiledPath
         ? readInterfConfig(options.builtCompiledPath)
         : null;
     const workflowLabel = `${options.dataset.workflow ?? "interf"}${compiledConfig?.workflow_origin?.local_draft === true ? " (local draft)" : ""}`;
     p.log.info(`Dataset: ${options.dataset.name}`);
-    p.log.info(`Path: ${options.dataset.path === "." ? "project root" : options.dataset.path}`);
+    p.log.info(`Path: ${options.dataset.path === "." ? "source folder" : options.dataset.path}`);
     if (options.dataset.about) {
         p.log.info(`About: ${options.dataset.about}`);
     }
@@ -60,12 +54,12 @@ async function promptDatasetAction(dataset, built, latestComparison) {
         options.push({
             value: "test",
             label: built
-                ? "Measure files-as-is and compiled accuracy (Recommended)"
+                ? "Compare files-as-is and compiled dataset (Recommended)"
                 : hasSavedRawBaseline
                     ? "Rerun the files-as-is baseline"
                     : "Measure the files-as-is baseline (Recommended)",
             hint: built
-                ? "Compare whether the compiled dataset is actually better on the saved checks"
+                ? "See whether preparation helps on the saved checks"
                 : hasSavedRawBaseline
                     ? "Refresh the saved raw baseline on the current checks"
                     : "See whether the raw dataset is already good enough before compiling",
@@ -162,6 +156,8 @@ async function chooseCompiledForWizard(options) {
 }
 async function promptCompiledSetup(options) {
     let workflowId = options.initial?.workflow ?? "interf";
+    let workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
+        .find((option) => option.value === workflowId)?.label ?? workflowId;
     if (options.introStyle === "edit") {
         const workflowChoice = await chooseCompiledWorkflow(options.sourcePath, {
             currentWorkflowId: workflowId,
@@ -170,9 +166,9 @@ async function promptCompiledSetup(options) {
         if (p.isCancel(workflowChoice))
             return null;
         workflowId = workflowChoice;
+        workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
+            .find((option) => option.value === workflowId)?.label ?? workflowId;
     }
-    const workflowLabel = buildCompiledWorkflowOptions(options.sourcePath)
-        .find((option) => option.value === workflowId)?.label ?? workflowId;
     const compiledConfig = await promptSingleCompiledConfig({
         projectPath: options.sourcePath,
         initial: options.initial,
@@ -206,31 +202,14 @@ async function promptCompiledSetup(options) {
     })}`));
     return compiledConfigWithWorkflow;
 }
-async function compileSelectedCompiled(sourcePath, compiledConfig) {
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
-        purpose: "compile",
-    });
-    if (!executor && !error) {
-        return null;
-    }
-    if (!executor) {
-        process.exitCode = 1;
-        console.log(chalk.red(error ?? "No coding agent detected."));
-        return null;
-    }
-    const compiledPath = ensureCompiledFromConfig(sourcePath, compiledConfig);
-    const compiled = await runConfiguredCompiledCompile({
-        executor,
-        compiledPath,
+export async function compileSelectedCompiled(sourcePath, compiledConfig, deps = {}) {
+    return (deps.runCompileCommand ?? runCompileCommand)({
         sourcePath,
-        compiledConfig,
-        maxAttemptsOverride: null,
-        maxLoopsOverride: null,
+        dataset: compiledConfig.name,
+        datasetConfig: compiledConfig,
+        skipConfirm: true,
+        skipDatasetBanner: true,
     });
-    if (!compiled) {
-        return null;
-    }
-    return compiledPath;
 }
 async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
     const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
@@ -251,7 +230,30 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         return;
     }
     if (action === "workflow") {
-        await createWorkflowWizard({ sourcePath });
+        const workflowId = await createWorkflowWizard({
+            sourcePath,
+            datasetContext: {
+                config: compiledConfig,
+                datasetPath: compiledConfig.path === "."
+                    ? sourcePath
+                    : resolve(sourcePath, compiledConfig.path),
+            },
+        });
+        if (typeof workflowId === "string") {
+            const nextConfig = {
+                ...compiledConfig,
+                workflow: workflowId,
+            };
+            upsertSourceDatasetConfig(sourcePath, nextConfig, {
+                matchName: compiledConfig.name,
+            });
+            const builtCompiledPath = findBuiltCompiledPath(sourcePath, compiledConfig.name);
+            if (builtCompiledPath) {
+                syncCompiledInterfConfigFromSourceDatasetConfig(builtCompiledPath, nextConfig);
+            }
+            p.log.info(`Assigned workflow "${workflowId}" to dataset "${compiledConfig.name}".`);
+            p.log.info("Next: run `interf compile`, then `interf test`.");
+        }
         return;
     }
     if (action === "dataset") {
@@ -316,8 +318,13 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
                 return;
             }
         }
-        const compiledPath = await compileSelectedCompiled(sourcePath, compiledConfig);
-        if (!compiledPath) {
+        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
+        if (!compileResult) {
+            return;
+        }
+        if (compileResult.testedDuringCompile) {
+            p.log.info("This compile run already tested the compiled dataset on the saved checks.");
+            p.log.info("Run `interf test` later if you want a fresh side-by-side comparison summary.");
             return;
         }
         await runTestCommand({
@@ -329,12 +336,13 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
         return;
     }
     if (action === "compile") {
-        if (!await compileSelectedCompiled(sourcePath, compiledConfig))
+        const compileResult = await compileSelectedCompiled(sourcePath, compiledConfig);
+        if (!compileResult)
             return;
         if (compiledConfig.checks.length === 0)
             return;
-        if (compileModeAlreadyRanSavedTests(compiledConfig)) {
-            p.log.info("Saved compile mode already ran the compiled-dataset test.");
+        if (compileResult.testedDuringCompile) {
+            p.log.info("This compile run already ran the compiled-dataset test.");
             return;
         }
         const runCompiledTest = await p.confirm({
@@ -356,19 +364,19 @@ async function runCompiledActionMenu(sourcePath, compiledConfig, options = {}) {
 }
 export const initCommand = {
     command: "init",
-    describe: "Open the root-folder wizard for this folder",
+    describe: "Open the dataset wizard for this folder",
     handler: async () => {
         await runInitCommand();
     },
 };
 export async function runInitCommand() {
-    p.intro(chalk.bold("Interf Compiler"));
-    p.log.info("Measure how accurately your local agents answer from the dataset in this folder, then compile only if it helps.");
+    p.intro(chalk.bold("Interf"));
+    p.log.info("Measure whether your local agents can answer the questions your task depends on from the data in this folder, then prepare the dataset only if the raw files are not good enough.");
     const cwd = process.cwd();
     const detected = detectInterf(cwd);
     const sourcePath = detected ? resolveSourceControlPath(detected.path) : cwd;
     if (detected) {
-        p.log.info(`Working from the dataset control plane: ${sourcePath}`);
+        p.log.info(`Working from the source folder: ${sourcePath}`);
     }
     const savedEntries = listSavedCompiledEntries(sourcePath);
     if (savedEntries.length === 0) {

package/dist/commands/list.js

@@ -9,7 +9,7 @@ export const listCommand = {
         const sourcePath = detected ? resolveSourceControlPath(detected.path) : process.cwd();
         const datasets = listSavedCompiledEntries(sourcePath);
         if (datasets.length === 0) {
-            console.log(chalk.dim("  Nothing found. Start with `interf`, run `interf test`, then compile a dataset when needed."));
+            console.log(chalk.dim("  Nothing found. Start with `interf` or `interf init` to define a dataset and save truth checks."));
             return;
         }
         console.log();
@@ -17,8 +17,11 @@ export const listCommand = {
         console.log();
         for (const dataset of datasets) {
             console.log(`  ${dataset.config.name}`);
-            console.log(chalk.dim(`    ${dataset.path ?? "not built yet"}`));
-            console.log(chalk.dim(`    workflow: ${dataset.config.workflow ?? "interf"}`));
+            if (dataset.config.about) {
+                console.log(chalk.dim(`    task: ${dataset.config.about}`));
+            }
+            console.log(chalk.dim(`    ${dataset.path ? "built" : "not built yet"} · path: ${dataset.config.path}`));
+            console.log(chalk.dim(`    workflow: ${dataset.config.workflow ?? "interf"}${dataset.localDraft ? " (local draft)" : ""}`));
             console.log(chalk.dim(`    checks: ${dataset.config.checks.length}`));
         }
     },

package/dist/commands/reset.js

@@ -3,7 +3,7 @@ import { detectInterf } from "../lib/interf.js";
 import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
 export const resetCommand = {
     command: "reset <scope>",
-    describe: "Reset generated compiled state while keeping source files",
+    describe: "Reset generated compiled state while keeping `raw/` and the local workflow package",
     builder: (yargs) => yargs.positional("scope", {
         type: "string",
         choices: ["compile", "all"],

package/dist/commands/source-config-wizard.d.ts

@@ -2,9 +2,9 @@ import type { SourceTruthCheck, SourceDatasetConfig } from "../lib/schema.js";
 export declare const DEFAULT_COMPILED_NAME = "dataset1";
 export declare const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
 export declare const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: forward-demand metrics, board-prep questions, or chart reads from this dataset.";
+export declare const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board-prep questions from these files, chart reads from this report, or tax review from these exports.";
 export declare const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
-export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+export declare const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export declare const DEFAULT_SELF_IMPROVING_LOOPS = 3;
 export type CompileLoopMode = "once" | "retry" | "self-improving";
 export interface CompileLoopSelection {

package/dist/commands/source-config-wizard.js

@@ -8,10 +8,11 @@ import { draftTruthChecks } from "./check-draft.js";
 export const DEFAULT_COMPILED_NAME = "dataset1";
 export const DEFAULT_COMPILED_CHECK_QUESTION_PLACEHOLDER = "A question you can already verify from this dataset";
 export const DEFAULT_COMPILED_CHECK_ANSWER_PLACEHOLDER = "The expected answer in plain English";
-export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: forward-demand metrics, board-prep questions, or chart reads from this dataset.";
+export const DEFAULT_COMPILED_ABOUT_PLACEHOLDER = "Example: board-prep questions from these files, chart reads from this report, or tax review from these exports.";
 export const DEFAULT_DATASET_PATH_PLACEHOLDER = "./dataset1";
-export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 1;
+export const DEFAULT_COMPILE_RETRY_ATTEMPTS = 3;
 export const DEFAULT_SELF_IMPROVING_LOOPS = 3;
+const DEFAULT_SELF_IMPROVING_ATTEMPTS = 1;
 function normalizeOptionalPromptText(value) {
     if (typeof value !== "string")
         return undefined;
@@ -75,9 +76,9 @@ export function defaultDatasetPathForPrompt(name, introStyle, cwd = process.cwd(
 }
 export function datasetAboutPromptMessage(introStyle) {
     if (introStyle === "edit") {
-        return "What should this dataset stay accurate about?";
+        return "What task should this dataset stay focused on?";
     }
-    return "What should this dataset be accurate about?";
+    return "What task should this dataset help with?";
 }
 function formatAttemptLabel(count, noun) {
     return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -95,10 +96,29 @@ export function describeCompileLoopSelection(options) {
         return "Compile once.";
     }
     if (mode === "retry") {
-        return "Compile retries are enabled for this dataset.";
+        const attempts = options.maxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
+        return `Compile retries are enabled for this dataset (${formatAttemptLabel(attempts, "total attempt")}).`;
     }
     const loops = options.maxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS;
-    return `Self-improving loops are enabled for this dataset (${formatAttemptLabel(loops, "workflow revision")}).`;
+    const attempts = options.maxAttempts ?? DEFAULT_SELF_IMPROVING_ATTEMPTS;
+    return `Self-improving loops are enabled for this dataset (${formatAttemptLabel(attempts, "attempt")} per variation, ${formatAttemptLabel(loops, "workflow revision")}).`;
+}
+async function promptCompileRetryAttempts(options) {
+    const maxAttempts = await p.text({
+        message: options.message,
+        placeholder: String(DEFAULT_COMPILE_RETRY_ATTEMPTS),
+        initialValue: String(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS),
+        validate: (value) => {
+            const parsed = Number.parseInt(value.trim(), 10);
+            if (!Number.isInteger(parsed) || parsed < 2 || parsed > 5) {
+                return "Enter a whole number from 2 to 5";
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(maxAttempts))
+        return null;
+    return compiledMaxAttempts(Number.parseInt(String(maxAttempts).trim(), 10)) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS;
 }
 export async function promptCheckCases(options) {
     p.log.info(options.heading);
@@ -263,7 +283,7 @@ async function promptCompiledChecks(options) {
         if (options.initialAbout) {
             p.log.info(`About: ${options.initialAbout}`);
         }
-        p.log.info("Truth checks are the questions this dataset should already answer correctly.");
+        p.log.info("Truth checks are the questions an agent should be able to answer from the data behind this task.");
         const mode = await p.select({
             message: "How do you want to create them?",
             options: [
@@ -420,8 +440,8 @@ export async function promptCompileLoopSelection(options) {
         return {};
     }
     const currentMode = resolveCompileLoopMode(options.initialMaxAttempts, options.initialMaxLoops);
-    const currentPromptMode = currentMode === "self-improving" ? "self-improving" : "once";
-    const recommendedMode = options.recommendedMode ?? "self-improving";
+    const currentPromptMode = currentMode;
+    const recommendedMode = options.recommendedMode ?? "once";
     const includeCompileOnce = options.includeCompileOnce !== false;
     const hasSavedPolicy = typeof options.initialMaxAttempts === "number" ||
         typeof options.initialMaxLoops === "number";
@@ -447,18 +467,20 @@ export async function promptCompileLoopSelection(options) {
         },
         retry: {
             value: "retry",
-            label: "Compile once",
-            hint: "Build the compiled dataset once with the selected workflow",
+            label: "Retry same workflow",
+            hint: `Retry compile and compiled-side truth checks up to ${options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS} total time${(options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS) === 1 ? "" : "s"} without editing the workflow`,
         },
     };
     const orderedModes = (hasSavedPolicy
         ? [
             currentPromptMode,
             ...(recommendedMode !== currentPromptMode ? [recommendedMode] : []),
+            "retry",
             "once",
         ]
         : [
             recommendedMode,
+            "retry",
             "once",
         ]).filter((mode, index, list) => list.indexOf(mode) === index)
         .filter((mode) => includeCompileOnce || mode !== "once");
@@ -471,6 +493,17 @@ export async function promptCompileLoopSelection(options) {
     if (selectedMode === "once") {
         return {};
     }
+    if (selectedMode === "retry") {
+        const maxAttempts = await promptCompileRetryAttempts({
+            initialMaxAttempts: options.initialMaxAttempts ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
+            message: "How many total attempts should Interf try before stopping?",
+        });
+        if (maxAttempts === null)
+            return null;
+        return {
+            max_attempts: maxAttempts,
+        };
+    }
     const maxLoops = await promptSelfImprovingLoops({
         initialMaxLoops: options.initialMaxLoops ?? DEFAULT_SELF_IMPROVING_LOOPS,
         message: "How many workflow revisions should Interf try?",
@@ -478,7 +511,7 @@ export async function promptCompileLoopSelection(options) {
     if (maxLoops === null)
         return null;
     return {
-        max_attempts: compiledMaxAttempts(DEFAULT_COMPILE_RETRY_ATTEMPTS) ?? DEFAULT_COMPILE_RETRY_ATTEMPTS,
+        max_attempts: DEFAULT_SELF_IMPROVING_ATTEMPTS,
         max_loops: maxLoops,
     };
 }
@@ -487,7 +520,7 @@ export async function promptSingleCompiledConfig(options = {}) {
     const introStyle = options.introStyle ?? "first";
     if (introStyle === "first") {
         p.log.info("Pick the dataset folder you want to measure.");
-        p.log.info("Then say what this dataset should be accurate about and save a few truth checks you can verify.");
+        p.log.info("Then say what task this dataset should help with and save a few truth checks you can verify.");
     }
     else if (introStyle === "additional") {
         p.log.info("Add another dataset only if this project needs a separate folder or set of truth checks.");
@@ -544,6 +577,9 @@ export async function promptSingleCompiledConfig(options = {}) {
     if (p.isCancel(datasetPath))
         return null;
     const normalizedDatasetPath = String(datasetPath).trim();
+    if (options.selectedWorkflowLabel) {
+        p.log.info(`Workflow: ${options.selectedWorkflowLabel}`);
+    }
     let compileLoopSelection = {
         ...(typeof initial?.max_attempts === "number" ? { max_attempts: initial.max_attempts } : {}),
         ...(typeof initial?.max_loops === "number" ? { max_loops: initial.max_loops } : {}),
@@ -573,11 +609,8 @@ export async function promptSingleCompiledConfig(options = {}) {
             initialMaxLoops: initial?.max_loops,
             hasChecks: checks.length > 0,
             intro: [
-                ...(options.selectedWorkflowLabel
-                    ? [`Workflow: ${options.selectedWorkflowLabel}`]
-                    : []),
                 "Compile mode",
-                "Choose whether this dataset should compile once or keep revising the workflow until it passes the same truth checks.",
+                "Choose whether this dataset should compile once, retry the same workflow, or try self-improving workflow variations on the same truth checks.",
             ],
         });
         if (compileLoopSelection === null)

package/dist/commands/test-flow.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createRawTestTarget, createCompiledTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "../lib/test.js";
 import { buildTestSpecFromSourceFolderConfig, buildTestSpecFromCompiledDatasetConfig, resolveSourceDatasetPath, } from "../lib/source-config.js";
-import { datasetArtifactRoot, datasetLatestTestStatePath, datasetLatestTestSummaryPath, datasetTestRunsRoot, } from "../lib/project-paths.js";
+import { datasetLatestTestStatePath, datasetLatestTestSummaryPath, normalizeDatasetTestRunId, datasetTestRunPath, datasetTestRunsRoot, datasetTestsRoot, } from "../lib/project-paths.js";
 import { testRootForCompiled } from "../lib/compiled-paths.js";
 import { readJsonFileWithSchema } from "../lib/parse.js";
 import { TestRunComparisonSchema } from "../lib/schema.js";
@@ -29,21 +29,10 @@ function summarizeSavedTestOutcome(label, outcome) {
         target: outcome.target,
     };
 }
-function normalizeTestRunId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-function datasetRunPathForTarget(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
-    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeTestRunId(runSuffix)}` : ""}.json`);
-}
 function writeDatasetTargetRun(options) {
     const dirPath = datasetTestRunsRoot(options.projectPath, options.datasetName, options.target);
     mkdirSync(dirPath, { recursive: true });
-    const runPath = datasetRunPathForTarget(options.projectPath, options.datasetName, options.target, options.generatedAt, options.runId, options.runSuffix);
+    const runPath = datasetTestRunPath(options.projectPath, options.datasetName, options.target, options.generatedAt, options.runId, options.runSuffix);
     writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
     return runPath;
 }
@@ -354,7 +343,7 @@ export async function runSavedRawTest(options) {
     const run = await runTargetTestsAuto(datasetSourcePath, spec, [target], {
         executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: datasetArtifactRoot(options.sourcePath, options.datasetConfig.name),
+        artifactRootPath: datasetTestsRoot(options.sourcePath, options.datasetConfig.name),
     });
     const result = run.results[0];
     if (!result)
@@ -364,7 +353,7 @@ export async function runSavedRawTest(options) {
         datasetName: options.datasetConfig.name,
         target: "file-as-is",
         generatedAt: run.generated_at,
-        runId: normalizeTestRunId(spec.id),
+        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });
@@ -413,7 +402,7 @@ export async function runSavedCompiledTest(options) {
         datasetName: options.datasetConfig.name,
         target: "compiled",
         generatedAt: run.generated_at,
-        runId: normalizeTestRunId(spec.id),
+        runId: normalizeDatasetTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });

package/dist/commands/test.d.ts

@@ -1,9 +1,3 @@
 import type { CommandModule } from "yargs";
-import type { SourceDatasetConfig } from "../lib/schema.js";
-export declare function resolveConfiguredDatasetSelection(options: {
-    sourcePath: string;
-    requestedDatasetName?: string | null;
-    hintedDatasetConfig?: SourceDatasetConfig | null;
-}): SourceDatasetConfig | null;
 export declare const testCommand: CommandModule;
 export declare function runTestCommand(argv?: Record<string, unknown>): Promise<boolean>;

package/dist/commands/test.js

@@ -3,19 +3,10 @@ import * as p from "@clack/prompts";
 import { detectInterf, resolveSourceControlPath, } from "../lib/interf.js";
 import { fingerprintTruthChecks, sourceDatasetConfigFromInterfConfig, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
-import { chooseCompiledConfigToBuild, findBuiltCompiledPath, findSavedCompiledConfig, } from "./compiled-flow.js";
+import { chooseCompiledConfigToBuild, findBuiltCompiledPath, } from "./compiled-flow.js";
+import { resolveConfiguredDatasetSelection } from "./dataset-selection.js";
 import { printAgentTestFailures, printAgentTestMatrix, printSavedTestComparisonState, readSavedTestComparison, runSavedRawTest, runSavedCompiledTest, saveTestComparisonRun, } from "./test-flow.js";
 import { listRunAgentOptions, promptForTestAgents, resolveNamedLocalExecutor, resolveOrConfigureLocalExecutor, } from "./executor-flow.js";
-export function resolveConfiguredDatasetSelection(options) {
-    if (options.hintedDatasetConfig &&
-        (!options.requestedDatasetName || options.hintedDatasetConfig.name === options.requestedDatasetName)) {
-        return options.hintedDatasetConfig;
-    }
-    if (!options.requestedDatasetName) {
-        return null;
-    }
-    return findSavedCompiledConfig(options.sourcePath, options.requestedDatasetName);
-}
 export const testCommand = {
     command: "test",
     describe: "Compare files as-is and a compiled dataset on saved truth checks",
@@ -156,17 +147,17 @@ async function resolveSelectedTestAgents(options) {
     ];
 }
 async function runModeForAgent(options) {
-    const rawOutcome = options.mode === "raw" || options.mode === "both"
-        ? await runSavedRawTest({
+    const rawPromise = options.mode === "raw" || options.mode === "both"
+        ? runSavedRawTest({
             sourcePath: options.sourcePath,
             datasetConfig: options.datasetConfig,
             executor: options.executor,
             preserveSandboxes: options.preserveSandboxes,
             runSuffix: options.executor.name,
         })
-        : null;
-    const compiledOutcome = options.mode === "compiled" || options.mode === "both"
-        ? await runSavedCompiledTest({
+        : Promise.resolve(null);
+    const compiledPromise = options.mode === "compiled" || options.mode === "both"
+        ? runSavedCompiledTest({
             sourcePath: options.sourcePath,
             datasetConfig: options.datasetConfig,
             compiledPath: options.builtCompiledPath,
@@ -174,7 +165,8 @@ async function runModeForAgent(options) {
             preserveSandboxes: options.preserveSandboxes,
             runSuffix: options.executor.name,
         })
-        : null;
+        : Promise.resolve(null);
+    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
     return {
         agentLabel: options.executor.displayName,
         rawOutcome,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { createCompiled, compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./lib/workflows.js";
-export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
+export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
 export { computeCompiledHealth, } from "./lib/state.js";
 export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
 export { validateCompiledSummarize, validateCompiledCompile, } from "./lib/validate.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { createCompiled, compileCompiled, runCompiledSummarize, runCompiledCompile, } from "./lib/workflows.js";
-export { createRawTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
+export { createRawTestTarget, createCompiledTestTarget, listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, listTestTargets, runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./lib/test.js";
 export { computeCompiledHealth, } from "./lib/state.js";
 export { SOURCE_FOLDER_CONFIG_FILE, loadSourceFolderConfig, buildTestSpecFromSourceFolderConfig, } from "./lib/source-config.js";
 export { validateCompiledSummarize, validateCompiledCompile, } from "./lib/validate.js";

package/dist/lib/agent-args.d.ts

@@ -1,3 +1,4 @@
 import type { WorkflowExecutionProfile } from "./executors.js";
 import type { Agent } from "./agent-types.js";
+export declare function buildAgentEnv(agent: Agent, baseEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function buildAgentArgs(agent: Agent, prompt: string, executionProfile?: WorkflowExecutionProfile): string[];

package/dist/lib/agent-args.js

@@ -1,4 +1,14 @@
 const CODEX_SANDBOX_MODE = `work${"space-write"}`;
+export function buildAgentEnv(agent, baseEnv = process.env) {
+    const env = { ...baseEnv };
+    if (agent.name === "codex") {
+        // Codex executes Bash-tool commands inside its own sandbox. Let Codex
+        // choose a sandbox-safe default shell instead of inheriting a host-only
+        // login shell path such as /bin/zsh.
+        delete env.SHELL;
+    }
+    return env;
+}
 export function buildAgentArgs(agent, prompt, executionProfile = {}) {
     if (agent.name === "claude-code") {
         const args = [

package/dist/lib/agent-execution.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import chalk from "chalk";
 import { CODEX_NOISE_PATTERNS } from "./agent-constants.js";
-import { buildAgentArgs } from "./agent-args.js";
+import { buildAgentArgs, buildAgentEnv } from "./agent-args.js";
 import { appendAgentEventLog, appendAgentStatusLog } from "./agent-logs.js";
 import { displayAgentEvent, emitVisibleAgentText, summarizeAgentToolActivity, } from "./agent-render.js";
 import { classifyTerminalVisibleStatus, extractAgentFailureStatus, hasAgentStalled, } from "./agent-status.js";
@@ -20,6 +20,7 @@ export function spawnAgent(agent, dirPath, prompt, options = {}) {
         appendAgentStatusLog(options.statusLogPath, launchLine);
         const proc = spawn(agent.command, args, {
             cwd: dirPath,
+            env: buildAgentEnv(agent),
             stdio: ["ignore", "pipe", "pipe"],
         });
         const timeoutMs = options.executionProfile?.timeoutMs ?? null;

package/dist/lib/agent-preflight.js

@@ -3,7 +3,7 @@ import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { CODEX_NOISE_PATTERNS } from "./agent-constants.js";
-import { buildAgentArgs } from "./agent-args.js";
+import { buildAgentArgs, buildAgentEnv } from "./agent-args.js";
 const successfulPreflightAgents = new Set();
 export function buildAgentPreflightPrompt() {
     return [
@@ -22,6 +22,7 @@ export function runAgentPreflight(agent, options = {}) {
         const result = spawnSyncImpl(agent.command, buildAgentArgs(agent, buildAgentPreflightPrompt()), {
             cwd: dirPath,
             encoding: "utf8",
+            env: buildAgentEnv(agent),
             timeout: timeoutMs,
         });
         const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";

package/dist/lib/agent-shells.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeContractType, WorkflowImprovementContext, WorkflowZoneId } from "./schema.js";
+import type { RuntimeContractType, SourceTruthCheck, WorkflowImprovementContext, WorkflowZoneId } from "./schema.js";
 export interface NativeStageDefinition {
     id: string;
     label: string;
@@ -8,6 +8,7 @@ export interface NativeStageDefinition {
     reads: WorkflowZoneId[];
     writes: WorkflowZoneId[];
 }
+export declare function writeNativeAgentSurface(rootPath: string, agentsContent: string, skillName: string, skillContent: string): boolean;
 export declare function renderCompiledAgents(compiledPath: string, name: string, workflowId: string, about?: string, options?: {
     workflowOriginSelected?: string | null;
     workflowLocalDraft?: boolean;
@@ -15,6 +16,30 @@ export declare function renderCompiledAgents(compiledPath: string, name: string,
 export declare function renderCompiledQuerySkill(): string;
 export declare function syncStageExecutionShellWrites(compiledPath: string, shellRoot: string, stage: NativeStageDefinition, writeArtifacts?: readonly string[]): void;
 export declare function renderClaudeBootstrap(content: string): string;
+export interface WorkflowAuthoringPreviewInfo {
+    compiledPath: string;
+    compileResult: {
+        ok: boolean;
+        failedStage: string | null;
+    };
+}
+export declare function createWorkflowAuthoringShell(options: {
+    workflowPath: string;
+    workflowId: string;
+    label: string;
+    baseWorkflowId: string;
+    datasetPath: string;
+    taskPrompt: string;
+    checks: SourceTruthCheck[];
+    preview?: WorkflowAuthoringPreviewInfo | null;
+}): {
+    rootPath: string;
+    workflowBeforePath: string;
+    workflowAfterPath: string;
+    promptLogPath: string;
+    eventLogPath: string;
+    statusLogPath: string;
+};
 export declare function pruneStageExecutionShells(compiledPath: string): void;
 export declare function projectCompiledQueryShell(compiledPath: string, compiledName: string, workflowId: string, about?: string, options?: {
     workflowOriginSelected?: string | null;