@interf/compiler 0.6.3 → 0.6.4

package/README.md

@@ -1,22 +1,14 @@
 # Interf
 
-Interf prepares task context for your agents.
+Interf prepares context for your agents.
 
-Start with the files behind a task and a few checks. Interf tests the files as-is first, shows what already works, and builds a local context folder when the current context is not good enough.
+Start with the files for the work you want to do. Tell Interf what you need, let it suggest a few questions to check later, and build portable context when the files alone are not enough.
 
-The result is a real folder your agent can open and work from. Interf retests it on the same checks, and self-improving loops can revise the workflow and try again until it passes or reaches the loop limit.
+It writes the result as a local folder inside your project. Your agents can use that folder directly, and Interf can check it on the same questions to show whether it actually helped.
 
-Raw files stay the source of truth. The context folder adds task-specific structure on top of them.
+Your source files stay the source of truth. Interf builds on them; it does not replace them.
 
-```bash
-cd ~/my-project
-interf
-interf test
-interf compile
-interf test
-```
-
-The context folder Interf builds is rooted at:
+Interf calls that folder portable context:
 
 ```text
 interf/<dataset>/
@@ -31,45 +23,52 @@ interf/<dataset>/
     tests/
 ```
 
-A recent run in this repo on the CBRE chart sanity task produced:
+For example, this repo tests a PDF market report with questions like:
+
+- `What were Bristol's annual take-up values in 2018 and 2016?`
+- `What were Bristol's availability values in 2018 and 2016?`
+
+On those same questions, a recent run in this repo produced:
 
 <!-- PUBLIC_BENCHMARK_TABLE:START -->
-| Agent | Files as-is | Context folder |
+| Agent | Source files | Portable context |
 | --- | --- | --- |
 | Codex (GPT-5.4, xhigh) | `2/2` | `2/2` |
 | Claude Code (Claude Opus 4.6, max) | `0/2` | `2/2` |
 <!-- PUBLIC_BENCHMARK_TABLE:END -->
 
-Those scores came from checks like:
+That means:
 
-- `What were Bristol's annual take-up values in 2018 and 2016?`
-- `What were Bristol's availability values in 2018 and 2016?`
+- Codex already passed on the source files.
+- Claude Code failed on the source files.
+- Both passed after Interf built the portable context.
 
-Same task. Same checks. Same local setup.
+Same work. Same questions. Same local setup.
 
 ## How It Works
 
-1. Start with a task and the files relevant to it.
-2. Save a few checks that tell Interf what "ready" means for that task.
-3. Run a workflow that prepares a source-backed context folder for the task.
-4. Test the result on the same checks and keep it only if it helped.
+1. Start with the files for the work.
+2. Tell Interf what you need from them.
+3. Let Interf recommend a few questions to check accuracy later, or edit them yourself.
+4. Build the portable context for that work.
+5. Run `interf test` on the same questions and keep the result only if it helped.
 
-The raw baseline is still important. It shows what already works on the files as-is and which local agent performs best before you spend time improving anything.
+Checking the source files first is still important. It shows what already works and which local agent performs best before you spend time improving anything.
 
 ## Why It Exists
 
-Local agents can open raw files and still reason badly over them. Reports, decks, transcripts, exports, PDFs, notes, and mixed folders may all be present, but they are often missing the structure a real task needs.
+Local agents can open raw files and still reason badly over them. Reports, decks, transcripts, exports, PDFs, notes, and mixed folders may all be present, but they are often missing the structure a real piece of work needs.
 
-Interf takes the files behind a task, prepares them into a local context folder your agents can use, and then proves whether the result helped.
+Interf takes the files for the work, builds a local folder your agents can use, and then checks whether it actually helped.
 
-Interf keeps the loop honest:
+Interf is built around a few simple rules:
 
-- `Value first`: prepare the data for a specific task, not just dump files into another app.
-- `Proof-backed`: test raw files and the prepared result on the same checks.
-- `One folder`: the context folder is a real folder you can inspect, diff, review, and version.
-- `Source-backed`: raw files remain the source of truth.
-- `Bring your own agent`: use the context folder manually from other local agents too. Automated Interf runs currently support Claude Code and Codex.
-- `Self-improving`: when checks fail, Interf can inspect the failed run, edit the workflow, and retest new workflow variations on the same checks. Retries keep the same workflow variation; loops change the workflow itself.
+- Start from the files you already have.
+- Check the source files and the portable context on the same questions.
+- Keep the result in a local folder you can inspect, diff, review, and version.
+- Keep raw files as the source of truth.
+- Use the portable context manually from Claude Code, Codex, or another local agent. Automated Interf runs currently support Claude Code and Codex.
+- If the first pass is not good enough, let Interf revise the workflow and try again. Retries keep the same workflow variation; loops change the workflow itself.
 
 ## What You Get
 
@@ -88,7 +87,7 @@ your-project/
       <dataset>/
 ```
 
-The context folder is the folder your agents should work from after Interf prepares the data for the task.
+After Interf runs, point your agents at the portable context first. Go back to the source files whenever you need to verify something.
 
 ## Quick Start
 
@@ -103,17 +102,18 @@ Install:
 npm install -g @interf/compiler
 ```
 
-Start from a project folder that contains one or more source folders for the task.
+Start from a project folder that contains one or more source folders for the work.
 
 The first run can:
 
 - draft `interf.json`
-- let you choose the source folder for the task
+- let you choose the source folder for the work
 - default the dataset id from that folder name, then let you change it
-- help you create checks for the task, or let you add them manually
-- run a files-as-is baseline on those checks so you can see what already works
-- build the context folder that stores the compiled context
-- let you test the context folder on the same checks
+- ask what work you need help with
+- recommend questions to check accuracy later, or let you add them manually
+- run a source-files baseline on those questions so you can see what already works
+- build the portable context for that work
+- let you check the portable context on the same questions
 
 If Interf cannot find your local executor setup, run:
 
@@ -121,19 +121,23 @@ If Interf cannot find your local executor setup, run:
 interf doctor --live
 ```
 
-## Checks
+## Questions
 
-Checks are the questions and expected answers Interf uses to prove whether the prepared result is good enough for this task.
+Interf uses simple question-and-answer checks to see whether the portable context is good enough for this work.
 
-They are just question-and-answer pairs you already know how to verify from the files behind the task.
+Each saved check stores a question and the expected answer. In `interf.json`, those definitions live under the technical field `checks[]`.
 
-Good first checks are small and practical:
+They are just question-and-answer pairs you can verify from the files you selected for the work.
+
+You do not need to write them from scratch before you know the data well. Interf can recommend a starting set from the files and the work description, then you can confirm, edit, or replace them. Their job is simple: check accuracy before you trust the portable context.
+
+Good first questions are small and practical:
 
 - one exact number from a chart, table, or filing
 - one short statement that should be true or false
 - one simple comparison across years, files, or sections
 
-A maintained public test run in this repo uses checks like this:
+A maintained public test example in this repo stores them like this:
 
 <!-- PUBLIC_TEST_CHECKS:START -->
 ```jsonc
@@ -161,33 +165,35 @@ A maintained public test run in this repo uses checks like this:
 
 ## What `interf test` Proves
 
-`interf test` compares files as-is and the context folder on the same checks.
+`interf test` compares the source files and the portable context on the same questions.
 
-That comparison is the product record:
+That comparison is the proof:
 
-- same task
-- same checks
+- same work
+- same questions
 - same local agent setup
-- raw files on one side
-- compiled context on the other
+- source files on one side
+- portable context on the other
 
 Use `interf test` on your own files instead of trusting a frozen benchmark snapshot in the docs.
 
-Interf saves the latest comparison plus detailed raw-side and context-folder runs under `interf/tests/` in the same folder.
+Interf saves the latest comparison plus the underlying source-files and portable-context runs under `interf/tests/` in the same project.
 
 ## The Core Loop
 
-1. Save a few checks for the task in `interf.json`.
-2. Optionally run `interf test` to see how the raw files do first.
-3. Run `interf compile` to prepare the data into a context folder.
-4. Run `interf test` again on the same checks.
+1. Save a few questions for the work in `interf.json`.
+2. Optionally run `interf test` to see how the source files do first.
+3. Run `interf compile` to build the portable context your agent can use.
+4. Run `interf test` again on the same questions.
 5. If loops are enabled, let Interf retry the same workflow variation or edit the workflow and test the new variation.
 
-The project root stores the source-folder setup and checks. The context folder carries the local compiled context needed for repeat runs.
+The project root stores the source-folder setup and saved questions. Technically, that portable context is the compiled context used for repeat runs.
 
 ## Workflows
 
-A workflow tells Interf how to prepare and structure the files for a task before your agent uses them.
+A workflow tells Interf how to prepare and structure the files for a kind of work before your agent uses them.
+
+Technically, a workflow package defines the context interface: the zones, paths, and stage ownership of the compiled context Interf will build for that work.
 
 Interf ships with a built-in `interf` workflow for the common case. If you need a different method, create one locally:
 
@@ -200,7 +206,7 @@ Workflow creation supports two paths:
 - draft a workflow from the current project with a local agent
 - copy an existing workflow and edit stage guidance directly
 
-After assignment, build the context folder with `interf compile` and run `interf test` on the same checks.
+After assignment, build the portable context with `interf compile` and run `interf test` on the same questions.
 
 ## Compile Loops
 
@@ -210,7 +216,7 @@ Retries keep the target fixed:
 
 - same configured dataset
 - same workflow variation
-- same checks
+- same questions
 - same measurement
 
 `max_loops` enables self-improving workflow edits in the normal `interf compile` path.
@@ -220,7 +226,7 @@ In that loop, the thing that changes is the workflow itself.
 Each loop can:
 
 - run the current workflow variation on the same configured dataset
-- test it on the same checks
+- test it on the same questions
 - inspect failed traces, preserved stage shells, and test artifacts
 - edit the workflow
 - build and test the next workflow variation
@@ -236,11 +242,11 @@ Paste something like this into your agent:
 ```text
 Install `@interf/compiler`, run `interf` in this folder, and use the local agent executor.
 
-If `interf.json` is missing, draft one dataset entry for this task with a few checks this agent should be able to answer from the selected files and add the expected answers for me to confirm.
+If `interf.json` is missing, draft one dataset entry for this work. Ask what I need from the selected files, recommend a few questions to check accuracy from those files, and add the expected answers for me to confirm. Store those checks under `checks[]`.
 
-Then run a files-as-is baseline if helpful, compile the context folder to prepare the data for that task, and run `interf test`.
+Then run a source-files baseline if helpful, build the portable context for that work, and run `interf test`.
 
-Tell me whether the context folder passes the checks, and only recommend it if it does.
+Tell me whether the portable context passes those questions, and only recommend it if it does.
 ```
 
 ## More Docs

package/dist/cli/commands/check-draft.js

@@ -11,12 +11,12 @@ export function buildTruthCheckDraftPrompt(options) {
     const normalizedAbout = options.about?.trim();
     const taskLines = normalizedAbout
         ? [
-            `Primary task: ${normalizedAbout}`,
-            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that task.",
+            `Primary work: ${normalizedAbout}`,
+            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that work.",
             "Prefer checks that would make a human confident the dataset is useful for that exact job.",
         ]
         : [
-            "No primary task was provided.",
+            "No primary work was provided.",
             "Prefer broad, representative checks that reflect the most useful questions a human would verify from this source folder.",
         ];
     return [
@@ -43,7 +43,7 @@ export function buildTruthCheckDraftPrompt(options) {
         "- Avoid unstable superlatives unless the source itself clearly states the ranking in one place.",
         "- Avoid checks where the expected answer depends on scanning many pages for a hidden exception or a larger outlier.",
         "- Avoid vague essay questions, open-ended opinions, or anything requiring outside knowledge.",
-        "- Avoid duplicate checks that test the same fact in slightly different words.",
+        "- Avoid duplicate checks that cover the same fact in slightly different words.",
         "",
         "Output rules:",
         "- JSON only in the output file.",

package/dist/cli/commands/compile-controller.js

@@ -3,11 +3,11 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../../packages/project-model/interf.js";
-import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../../packages/project-model/compiled-reset.js";
+import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../../packages/compiler/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 { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../../packages/compiler/compiled-paths.js";
 import { readCompiledSchemaFile } from "../../packages/compiler/compiled-schema.js";
 import { initializeCompiledRuntimeState } from "../../packages/compiler/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
@@ -78,16 +78,16 @@ async function runWorkflowVariation(options) {
                 const resetTarget = attempt > 1
                     ? `attempt ${attempt}/${options.maxAttempts}`
                     : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated compiled-context state before ${resetTarget}...`));
+                console.log(chalk.dim(`  Resetting generated portable-context state before ${resetTarget}...`));
                 resetCompiledGeneratedState(options.compiledPath, "compile");
             }
             const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building compiled context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building compiled context (${options.variationLabel})...`,
+                    ? `Building portable context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building portable context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Compiled context ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Compiled context ready for ${options.variationLabel}.`,
+                    ? `Portable context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Portable context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
             });
             if (!result.ok) {
@@ -123,7 +123,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved compiled-context check after compile.",
+                    fatalError: "Could not run the saved portable-context comparison after compile.",
                 };
             }
             console.log();
@@ -181,11 +181,11 @@ 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} checks.`
+        ? `Passed ${passedQuestions}/${totalQuestions} questions.`
         : options.result.bestOutcome
-            ? `Best result: ${passedQuestions}/${totalQuestions} checks passed.`
+            ? `Best result: ${passedQuestions}/${totalQuestions} questions passed.`
             : options.result.failedStage
-                ? `Compile failed at stage ${options.result.failedStage} before any test result.`
+                ? `Compile failed at stage ${options.result.failedStage} before any saved comparison result.`
                 : "Workflow variation did not produce a passing result.";
     return {
         variation: options.variation,
@@ -213,16 +213,16 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
     }
 }
 function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Context folder: ${options.compiledPath}`));
+    console.log(chalk.dim(`  Portable context: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add checks, then `interf test`."));
+        console.log(chalk.dim("  Next: run `interf` to add questions, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the compiled context, or run `interf test` if you also want a raw-versus-compiled-context comparison."));
+        console.log(chalk.dim("  Next: inspect the portable context, or run `interf test` if you also want a source-files-versus-portable-context comparison."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to compare the raw files and the compiled context."));
+    console.log(chalk.dim("  Next: run `interf test` to compare the source files and the portable context."));
 }
 function formatVariationQuestionSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
@@ -233,7 +233,7 @@ function printWorkflowVariationSummary(summaries) {
     console.log();
     console.log(chalk.bold("  Workflow variation summary"));
     console.log();
-    console.log("  | Variation | Kind | Checks | Result |");
+    console.log("  | Variation | Kind | Questions | Result |");
     console.log("  | --- | --- | --- | --- |");
     for (const summary of summaries) {
         console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
@@ -245,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 context reuses that local workflow draft."));
+    console.log(chalk.dim("  Recompiling this existing portable context reuses that local workflow draft."));
 }
 export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
@@ -255,12 +255,12 @@ 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 checks. Building once without those loops."));
+        console.log(chalk.yellow("  Retry and self-improving modes need saved questions. 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 will rerun the same workflow variation, test the compiled context, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same workflow variation, check the portable context, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
@@ -414,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 context from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing portable 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 context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Context folder 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 context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Context folder did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt check pass rate: ${questionPassRate(bestOutcome)}%.`));
+            console.log(chalk.dim(`  Best attempt test pass rate: ${questionPassRate(bestOutcome)}%.`));
         }
         printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;

package/dist/cli/commands/compile.js

@@ -11,10 +11,10 @@ import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build a compiled context and optionally run retry or self-improving compile loops",
+    describe: "Build portable context and optionally run retry or self-improving compile loops",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
         type: "number",
-        describe: "Retry compile + check for the same workflow until the dataset passes or reaches this total attempt limit",
+        describe: "Retry compile and test the same workflow until the dataset passes or reaches this total attempt limit",
     }).option("max-loops", {
         type: "number",
         describe: "After retries fail, let Interf edit the workflow and test new workflow variations for this dataset up to this loop limit",

package/dist/cli/commands/compiled-flow.js

@@ -11,8 +11,8 @@ function formatSavedDatasetHint(entry) {
     if (config.about)
         return `${config.path} · ${config.about} · ${workflowHint}`;
     if (checkCount === 0)
-        return `${config.path} · No checks yet · ${workflowHint}`;
-    return `${config.path} · ${checkCount} check${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
+        return `${config.path} · No questions yet · ${workflowHint}`;
+    return `${config.path} · ${checkCount} question${checkCount === 1 ? "" : "s"} · ${workflowHint}`;
 }
 export function listSavedCompiledEntries(sourcePath) {
     const builtEntries = new Map();
@@ -82,7 +82,7 @@ export function ensureCompiledFromConfig(sourcePath, datasetConfig) {
 }
 export async function compileCompiledWithReporter(executor, compiledPath, options = {}) {
     console.log();
-    console.log(chalk.bold(`  ${options.heading ?? "Building compiled context..."}`));
+    console.log(chalk.bold(`  ${options.heading ?? "Building portable context..."}`));
     const profileLabel = formatWorkflowExecutionProfile(executor.executionProfile);
     if (profileLabel) {
         console.log(chalk.dim(`  Execution profile: ${profileLabel}`));
@@ -102,6 +102,6 @@ export async function compileCompiledWithReporter(executor, compiledPath, option
         return result;
     }
     console.log();
-    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Compiled context ready."}`));
+    console.log(chalk.green(`  ✓ ${options.successMessage ?? "Portable context ready."}`));
     return result;
 }

package/dist/cli/commands/create-workflow-wizard.js

@@ -7,7 +7,7 @@ import { isWorkflowId, } from "../../packages/workflow-package/local-workflows.j
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { runWorkflowAuthoringDraft } from "../../packages/workflow-authoring/workflow-authoring.js";
 import { listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, } from "../../packages/project-model/source-config.js";
-import { slugify } from "../../lib/util.js";
+import { slugify } from "../../packages/shared/naming.js";
 import { DEFAULT_DATASET_PATH_PLACEHOLDER, listDatasetFolderChoices, normalizeDatasetPathForConfig, } from "./source-config-wizard.js";
 export const clackWorkflowPrompts = {
     intro: p.intro,
@@ -31,7 +31,7 @@ function findMatchingDatasetConfig(sourcePath, datasetPath) {
 function describeSavedDataset(dataset) {
     return dataset.about
         ? `${dataset.path} · ${dataset.about}`
-        : `${dataset.path} · ${dataset.checks.length} check${dataset.checks.length === 1 ? "" : "s"}`;
+        : `${dataset.path} · ${dataset.checks.length} test${dataset.checks.length === 1 ? "" : "s"}`;
 }
 async function promptWorkflowDatasetFolder(sourcePath, prompts) {
     const folderChoices = listDatasetFolderChoices(sourcePath);
@@ -136,7 +136,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             {
                 value: "draft",
                 label: "Draft a workflow from this source folder (Recommended)",
-                hint: "Seed a workflow, build a preview, then let a local agent draft a reusable method for this task",
+                hint: "Seed a workflow, build a preview, then let a local agent draft a reusable method for this kind of work",
             },
             {
                 value: "manual",
@@ -214,9 +214,9 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             matchedDataset = matchedDataset ?? findMatchingDatasetConfig(sourcePath, datasetPath);
         }
         const taskPrompt = await prompts.text({
-            message: "What task should this workflow help with?",
-            placeholder: "Example: chart reads, board-prep questions, or latest planned launch status",
-            validate: (value) => (value.trim().length === 0 ? "Task focus is required" : undefined),
+            message: "What kind of work should this workflow help with?",
+            placeholder: "Example: chart reads, board prep, or latest planned launch status",
+            validate: (value) => (value.trim().length === 0 ? "Work focus is required" : undefined),
         });
         if (prompts.isCancel(taskPrompt))
             return taskPrompt;
@@ -224,7 +224,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
             prompts.log.info(`Shaping this workflow from setup "${matchedDataset.name}".`);
         }
         if (matchedDataset?.checks.length) {
-            prompts.log.info(`Using ${matchedDataset.checks.length} check${matchedDataset.checks.length === 1 ? "" : "s"} from setup "${matchedDataset.name}" as authoring context.`);
+            prompts.log.info(`Using ${matchedDataset.checks.length} saved question${matchedDataset.checks.length === 1 ? "" : "s"} from setup "${matchedDataset.name}" as authoring context.`);
         }
         const resolveExecutor = options.resolveExecutor ?? resolveOrConfigureLocalExecutor;
         const runDraft = options.runDraft ?? runWorkflowAuthoringDraft;
@@ -259,7 +259,7 @@ export async function createCompiledWorkflowWizard(sourcePath, prompts = clackWo
         }
         process.exitCode = 1;
         (prompts.log.error ?? prompts.log.info)(result.status === "no-change"
-            ? `${result.summary} Draft mode only succeeds when it produces a task-specific package change.`
+            ? `${result.summary} Draft mode only succeeds when it produces a work-specific package change.`
             : result.summary);
         prompts.log.info(`Workflow shell kept at: ${result.shellPath}`);
         return null;

package/dist/cli/commands/create.js

@@ -61,7 +61,7 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
             options: datasets.map((dataset) => ({
                 value: dataset.name,
                 label: dataset.name,
-                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} check${dataset.checks.length === 1 ? "" : "s"}`}`,
+                hint: `${dataset.path} · ${dataset.about ?? `${dataset.checks.length} question${dataset.checks.length === 1 ? "" : "s"}`}`,
             })),
         });
         if (p.isCancel(selected))
@@ -83,7 +83,7 @@ async function maybeAssignWorkflowToDataset(sourcePath, workflowId) {
     }
     p.log.info(`Assigned workflow "${workflowId}" to dataset "${targetDataset.name}".`);
     if (builtCompiledPath) {
-        p.log.info("The active local copy for that compiled context lives under `.interf/workflow/`.");
+        p.log.info("The active local workflow copy for that portable context lives under `.interf/workflow/`.");
     }
     p.log.info("Next: run `interf compile`, then `interf test`.");
 }
@@ -132,14 +132,14 @@ export async function createCompiledWizard(options = {}) {
     const detected = detectInterf(cwd);
     if (detected) {
         process.exitCode = 1;
-        p.log.error("You are already inside a compiled context.");
+        p.log.error("You are already inside portable context.");
         return;
     }
     const savedDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(cwd));
     if (savedDatasets.length > 0) {
-        p.log.info(`This project already has ${savedDatasets.length} saved setup${savedDatasets.length === 1 ? "" : "s"} in interf.json. Add another only when you need a separate folder, focus, or check set.`);
+        p.log.info(`This project already has ${savedDatasets.length} saved setup${savedDatasets.length === 1 ? "" : "s"} in interf.json. Add another only when you need a separate folder, focus, or question set.`);
     }
-    p.log.info("Interf works one source-folder setup at a time. Start with the task, the relevant files, and a few checks, then build a context folder when you want to prepare that task context for your agents.");
+    p.log.info("Interf works one source-folder setup at a time. Start with the work, the relevant files, and a few questions, then build portable context when you want to prepare context your agents can work from.");
     const existingConfig = loadSourceFolderConfig(cwd);
     const draft = await promptSingleCompiledConfig({
         projectPath: cwd,

package/dist/cli/commands/default.js

@@ -5,7 +5,7 @@ function printStaticLanding() {
     const config = userConfig.loadUserConfig();
     console.log();
     console.log(chalk.bold("  Interf"));
-    console.log(chalk.dim("  Prepare task context for your agents from the files behind a task, then test it and use self-improving loops until the checks pass."));
+    console.log(chalk.dim("  Prepare context for your agents from the files you already have, then run `interf test` and use self-improving loops until more questions pass."));
     console.log();
     if (config) {
         console.log(chalk.dim(`  Agent: ${config.agent}`));