@interf/compiler 0.6.3 → 0.6.5

package/README.md

@@ -1,79 +1,78 @@
 # 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 accuracy, and build portable context for your agents 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.
+Interf Compiler builds portable context in a local folder inside your project.
+Your agents can use it directly. Interf can check it on those same questions.
 
-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:
+For the built-in `interf` workflow, a portable context can include:
 
 ```text
 interf/<dataset>/
-  AGENTS.md
-  CLAUDE.md
-  raw/
-  <workflow-declared compiled outputs>
-  .interf/
-    interf.json
-    workflow/
-    runtime/
-    tests/
+  AGENTS.md      # how your agent should use this folder
+  CLAUDE.md      # same guidance for Claude Code
+  home.md        # top-level map for the work
+  summaries/     # file-by-file summaries
+  knowledge/     # linked notes built from those files
 ```
 
-A recent run in this repo on the CBRE chart sanity task produced:
+That is an example, not a fixed ABI. Different workflows can build different folders. The simple part is that your agent gets one local folder to start from.
+
+This repo includes a small PDF example 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 needed the portable context to pass.
 
-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. Pick the files for the work.
+2. Tell Interf what you need from them.
+3. Review or edit the questions.
+4. Build the portable context for your agents.
+5. Run `interf test` on the same questions.
 
-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.
+Check the source files first if you want the baseline. If the files already pass, keep them. If the portable context does better, use it.
 
 ## 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.
+Raw files are often not enough.
+
+Local agents can open reports, decks, transcripts, exports, PDFs, notes, and mixed folders. They can still miss the structure the 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 builds a local folder for that work and checks whether it 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 source files and portable context on the same questions.
+- Keep the result in a local folder you can inspect, diff, review, and version.
+- Keep source 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 enough, let Interf retry the same workflow or improve the workflow itself.
 
 ## What You Get
 
-A project with one saved setup stays simple:
+A small project can stay simple:
 
 ```text
 your-project/
@@ -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 `interf/<dataset>/` first. Go back to the source files whenever you need to verify something.
 
 ## Quick Start
 
@@ -103,17 +102,21 @@ Install:
 npm install -g @interf/compiler
 ```
 
-Start from a project folder that contains one or more source folders for the task.
+Then run Interf in a project folder that already contains the files for the work:
 
-The first run can:
+```bash
+interf
+```
+
+The first run opens the dataset wizard for that folder. It can:
 
 - draft `interf.json`
-- let you choose the source folder for the task
-- 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
+- let you choose the source folder for the work
+- ask what work you need help with
+- recommend questions to check accuracy, or let you add them manually
+- run a source-files baseline so you can see what already works
+- build the portable context your agents will use for that work
+- check that portable context on the same questions
 
 If Interf cannot find your local executor setup, run:
 
@@ -121,19 +124,21 @@ 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 questions to check whether the portable context is good enough for your agents on this work.
 
-They are just question-and-answer pairs you already know how to verify from the files behind the task.
-
-Good first checks are small and practical:
+Good first questions are small and easy to verify from the files:
 
 - 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:
+Interf can recommend a starting set from the files and the work description. You can confirm, edit, or replace them.
+
+Each saved question includes the expected answer. In `interf.json`, those definitions live under the technical field `checks[]`.
+
+A maintained public test example in this repo stores them like this:
 
 <!-- PUBLIC_TEST_CHECKS:START -->
 ```jsonc
@@ -161,33 +166,39 @@ 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 your agents would use on the same questions.
 
-That comparison is the product record:
+That comparison is the proof step:
 
-- 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 your agents use on the other
+
+If the portable context does not help, keep the source files.
 
 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.
-5. If loops are enabled, let Interf retry the same workflow variation or edit the workflow and test the new variation.
+1. Save a few questions for the work in `interf.json`.
+2. Check the source files first if you want the baseline.
+3. Run `interf compile` to build the portable context your agents can use.
+4. Run `interf test` on the same questions.
+5. If loops are enabled, let Interf retry the same workflow variation or improve the workflow and test again.
 
-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 Interf reuses 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 is the method Interf uses to prepare files for a kind of work.
+
+A context interface is the folder shape that workflow builds for your agent.
+
+Technically, a workflow package defines that 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,47 +211,34 @@ 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 for your agents with `interf compile` and run `interf test` on the same questions.
 
 ## Compile Loops
 
 `max_attempts` is a retry budget for the same workflow variation.
 
-Retries keep the target fixed:
-
-- same configured dataset
-- same workflow variation
-- same checks
-- same measurement
-
-`max_loops` enables self-improving workflow edits in the normal `interf compile` path.
-
-In that loop, the thing that changes is the workflow itself.
+`max_loops` lets Interf improve the workflow itself between retry batches.
 
-Each loop can:
+With `max_attempts`, the dataset, questions, and workflow stay fixed.
 
-- run the current workflow variation on the same configured dataset
-- test it on the same checks
-- inspect failed traces, preserved stage shells, and test artifacts
-- edit the workflow
-- build and test the next workflow variation
+With `max_loops`, Interf can edit the workflow, build the next variation, and test it again on the same dataset and questions.
 
-Interf preserves workflow-improvement shells, workflow-before / workflow-after snapshots, failed stage shells, and test runs from each loop so you can inspect exactly what changed.
+Interf preserves workflow snapshots, failed stage shells, and test runs from each loop so you can inspect what changed.
 
 ## Use It With Your Agent
 
-If you already work through a local coding agent, it can run this process for you.
+If you already work through a local coding agent, hand it the whole flow:
 
 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 I can verify from those files, and add the expected answers for me to confirm 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`.
+Run a source-files baseline if useful. Build the portable context for my agents for that work. Then run `interf test` on the same questions.
 
-Tell me whether the context folder passes the checks, and only recommend it if it does.
+Only recommend the portable context if it passes those questions. If you also ran the source-files baseline, tell me whether it did better than the source files.
 ```
 
 ## 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 your agents will use, 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 your agents would use."));
 }
 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 for your agents, 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 for your agents 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 for your agents when the files alone are not enough.");
     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}`));