@pmelab/gtd 58.2.0 → 59.0.0

package/dist/gtd.bundle.mjs

@@ -20888,12 +20888,7 @@ const restorability = (git, headHash, tipHash) => gen(function* () {
 });
 //#endregion
 //#region src/flags/index.ts
-const FLAGS$1 = [{
-	name: "risk_tier",
-	owner: "pmelab",
-	expiry: "2027-01-15",
-	kind: "release"
-}];
+const FLAGS$1 = [];
 const BOOL = {
 	"0": false,
 	false: false,
@@ -20935,6 +20930,7 @@ const findPackageJson = (fromUrl) => {
 const GTD_VERSION = _require(findPackageJson(import.meta.url)).version;
 //#endregion
 //#region src/install/Install.ts
+const WORKFLOWS_REPO = "https://github.com/pmelab/gtd-workflows";
 const MINIMAL_DRIVER = `#!/usr/bin/env sh
 set -eu
 
@@ -21016,7 +21012,7 @@ while :; do
       system="$(gtd next --json=system)"
       validate="$(gtd next --json=validate)"
       log="$(gtd next --json=log)"
-      # \`model\` is a hint, not a model name — the bundled workflow ships
+      # \`model\` is a hint, not a model name — gtd-workflows' default ships
       # \`smart\` and \`base\`, which \`claude --model\` rejects. Resolve them
       # from your environment; unset, the hint is dropped and the agent runs
       # its own default. Any other value is a real model name.
@@ -21338,14 +21334,37 @@ follow in the same numbered list.
    existing config, the project's own README/docs) and ask the user what
    they're trying to accomplish with gtd here — don't assume a fresh
    install or silently start a process on their behalf.
-2. **Make sure a \`gtd.config.ts\` governs the repository.** Run at the
-   repository root, \`gtd install\` writes one importing gtd's shipped
-   workflows when none exists yet (its own message says so). Repository
-   settings — steering-file modes, \`gtd ui\`, per-scope skills and access —
-   go in its \`config\` export; workflow settings are options of the
-   workflow factory it exports.
-3. **Commit the config before the first drive.** \`gtd install\` leaves the
-   file it writes uncommitted on purpose — an uncommitted config is a
+2. **Make sure a \`gtd.config.ts\` governs the repository.** gtd ships no
+   workflow: the config imports the workflows it runs. Ask the user which
+   way they want:
+   - **A workflow from ${WORKFLOWS_REPO}.** Its \`default\` is a feature →
+     review → fix workflow. It is used from a checkout pinned on this
+     machine:
+
+     \`\`\`sh
+     git clone ${WORKFLOWS_REPO} ~/.local/share/gtd/workflows
+     ~/.local/share/gtd/workflows/bin/gtd-wf pin origin/main   # or a tag
+     ~/.local/share/gtd/workflows/bin/gtd-wf config default > gtd.config.ts
+     \`\`\`
+
+     \`pin\` checks the ref out and bundles each workflow; \`config\` prints a
+     config importing the bundle by its ABSOLUTE path. Tell the user what
+     that means: the committed config works only where the checkout sits at
+     that same path, so a teammate or CI needs their own checkout there (or
+     their own config). If a checkout exists already, \`gtd-wf status\`
+     shows its pin — reuse it rather than cloning again. Read the
+     repository's README for the workflows it offers and their options.
+   - **Their own workflow.** A workflow is TypeScript the config exports,
+     written against \`@pmelab/gtd/flows\` — see
+     https://github.com/pmelab/gtd/blob/main/docs/configuration.md, and
+     https://github.com/pmelab/gtd/blob/main/docs/testing.md to test it. A
+     copy of a gtd-workflows workflow (\`gtd-wf new <name> --from default\`
+     in a clone of it) is a good start.
+
+   Repository settings — steering-file modes, \`gtd ui\`, per-scope skills
+   and access — go in the config's \`config\` export; workflow settings are
+   options of the workflow factory it exports.
+3. **Commit the config before the first drive.** An uncommitted config is a
    pending change, so starting a process without committing it first turns
    the config into the very first thing the process plans against. Commit
    it, THEN start driving.
@@ -21371,7 +21390,8 @@ follow in the same numbered list.
    from every prompt line and writing no model exports, so every turn runs
    on the chosen CLI's own default tier.
 6. **If model hints are honored, resolve them to real model identifiers.**
-   The bundled workflow ships \`plannerModel: smart\` and \`coderModel: base\`.
+   A workflow may declare model hints — gtd-workflows' \`default\` ships
+   \`plannerModel: smart\` and \`coderModel: base\`.
    **Those are opaque hints, not model names** — gtd never interprets them,
    and passing \`--model smart\` to a real CLI fails on the first prompt
    beat. Derive the chosen CLI's own available models at install time — its
@@ -21468,11 +21488,8 @@ hands off to \`gtd-build\`, which halts at the blocked gate and prints it,
 rather than starting the review; \`gtd-door fix\` on a GREEN suite is a no-op
 straight back to \`idle\` — the exec'd \`gtd-build\` exits immediately on it.
 \`gtd doors\` lists the doors a repository offers (those of the workflows its
-config exports — the bundled \`fix\` and \`review [base]\`, plus the opt-in
-\`rollout <flag>\` (turn a release flag default-on) and \`cleanup <flag>\`
-(remove it), which a config adds by exporting \`rollout\` from
-\`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
-\`@pmelab/gtd/workflows/cleanup\` — plus any it declares). Refuses with
+config exports — gtd-workflows' \`default\` brings \`fix\` and
+\`review [base]\` — plus any the config declares). Refuses with
 \`usage: gtd-door <name> [args...]\` on stderr and exit \`2\` when the name is
 missing — nothing was even attempted. Default path: \`~/.local/bin/gtd-door\`.
 
@@ -21587,28 +21604,6 @@ Any runtime works: the contract is \`--json\`/\`--json=<path>\` in, subprocesses
 out.
 `;
 const renderBriefing = () => HEADER() + BEAT_PROTOCOL + JSON_FIELD_REFERENCE + DRIVER_OBLIGATIONS + RECOVERY + commandSuite() + EDITOR_INTEGRATION + PREREQUISITES;
-//#endregion
-//#region src/install/ConfigScaffold.ts
-const CONFIG_SCAFFOLD = `// The workflows gtd runs here: gtd's shipped feature, review and fix.
-// Every exported function is startable with \`gtd --workflow <name>\`; the
-// default export is what a change in the tree starts. Each workflow brings
-// its own doors: \`gtd door review [base]\` and \`gtd door fix\`. Export \`rollout\`
-// from \`@pmelab/gtd/workflows/rollout\` and \`cleanup\` from
-// \`@pmelab/gtd/workflows/cleanup\` to add \`gtd door rollout <flag>\` and
-// \`gtd door cleanup <flag>\`.
-export {
-  feature as default,
-  feature,
-  defaults,
-  envDefaults,
-  summary,
-  steering,
-  skills,
-  access,
-} from "@pmelab/gtd/workflows/feature"
-export { review } from "@pmelab/gtd/workflows/review"
-export { fix } from "@pmelab/gtd/workflows/fix"
-`;
 var FlowsProtocolError = class extends Error {
 	constructor(engine, flows) {
 		super(`gtd: the workflow speaks flows protocol ${flows}, but the engine installed protocol ${engine} — ${engine < flows ? "upgrade the gtd that runs it" : "upgrade the @pmelab/gtd the workflow imports"}`);
@@ -38953,13 +38948,35 @@ const resolveVars = (workflowVars, entryVars, env) => {
 	}
 	return merged;
 };
+const FLAG_VALUES = {
+	"0": "0",
+	false: "0",
+	"1": "1",
+	true: "1"
+};
+const flagVariable = (setting) => `GTD_FLAG_${setting.slice(5).toUpperCase()}`;
+/** The `flag_<name>` settings a workflow declares that gtd's own flags lack: the workflow's own release flags. */
+const ownFlags = (workflowVars, flags) => Object.keys(workflowVars).filter((name) => name.startsWith("flag_") && !Object.hasOwn(flags, name));
+/** Why a workflow's own release flag cannot start, if one is set to anything but 1, 0, true or false. */
+const ownFlagRefusal = (workflowVars, flags, env) => {
+	const bad = ownFlags(workflowVars, flags).find((name) => {
+		const raw = env[flagVariable(name)] ?? "";
+		return raw !== "" && !Object.hasOwn(FLAG_VALUES, raw.toLowerCase());
+	});
+	return bad === void 0 ? void 0 : `${flagVariable(bad)} must be 1, 0, true or false`;
+};
 /**
 * `resolveVars` for a process being STARTED: `flags` land between the workflow
-* defaults and `--var`, for already-declared names only. A running process never
-* calls this — it replays its pinned record.
+* defaults and `--var`, for already-declared names only, and so does
+* `GTD_FLAG_<NAME>` for a `flag_<name>` the workflow declares itself. A running
+* process never calls this — it replays its pinned record.
 */
 const resolveStartVars = (workflowVars, flags, entryVars, env) => {
 	const declared = Object.fromEntries(Object.entries(flags).filter(([name]) => Object.hasOwn(workflowVars, name)));
+	for (const name of ownFlags(workflowVars, flags)) {
+		const value = FLAG_VALUES[(env[flagVariable(name)] ?? "").toLowerCase()];
+		if (value !== void 0) declared[name] = value;
+	}
 	return resolveVars({
 		...workflowVars,
 		...declared
@@ -39163,7 +39180,7 @@ const load = gen(function* () {
 		const missing = {
 			severity: "error",
 			path: [],
-			message: `no workflows configured: no ${WORKFLOW_MODULE} here or above — run \`gtd install\` to scaffold one`,
+			message: `no workflows configured: no ${WORKFLOW_MODULE} here or above — gtd ships no workflow; \`gtd install\` says where to get one`,
 			origin: host.root
 		};
 		return yield* fail$7(configError([missing]));
@@ -39919,7 +39936,11 @@ const planStart = (current, actor, start) => gen(function* () {
 	const overrideRefusal = yield* checkOverrides(commandLabel, varOverrides, Object.keys(workflow.vars), Object.keys(workflow.env));
 	if (overrideRefusal !== void 0) return overrideRefusal;
 	const baseOf = workflow.def.base;
-	const vars = resolveStartVars(workflow.vars, yield* StartFlags, varOverrides, (yield* Host).env);
+	const flags = yield* StartFlags;
+	const hostEnv = (yield* Host).env;
+	const badFlag = ownFlagRefusal(workflow.vars, flags, hostEnv);
+	if (badFlag !== void 0) return refusal(`${commandLabel}: ${badFlag}`);
+	const vars = resolveStartVars(workflow.vars, flags, varOverrides, hostEnv);
 	const multiline = multilineSetting(vars);
 	if (multiline !== void 0) return refusal(`${commandLabel}: process setting "${multiline}" spans several lines — a process setting is pinned in a commit trailer and must be a single line`);
 	const template = yield* try_({
@@ -40782,11 +40803,11 @@ const historySteps = (run) => {
 		};
 	});
 };
-const versionWarningFor = (recorded) => recorded === GTD_VERSION ? void 0 : `gtd: warning: this history was recorded by ${recorded === void 0 ? "an unknown gtd version" : `gtd ${recorded}`} and is replayed by gtd ${GTD_VERSION} — a workflow imported from @pmelab/gtd/workflows may have changed since`;
+const versionWarningFor = (recorded) => recorded === GTD_VERSION ? void 0 : `gtd: warning: this history was recorded by ${recorded === void 0 ? "an unknown gtd version" : `gtd ${recorded}`} and is replayed by gtd ${GTD_VERSION} — the engine the workflow runs on may have changed since`;
 /**
 * Replays the closed run at `tip` under today's config. The workflow is not
-* fingerprinted for a version change: one imported from `@pmelab/gtd/workflows`
-* moves with every upgrade, and the version warning is the only signal.
+* fingerprinted for a version change: the engine under it moves with every
+* upgrade, and the version warning is the only signal.
 */
 const historyTrail = (tip) => gen(function* () {
 	const git = yield* GitService;
@@ -42015,9 +42036,8 @@ const selfGtd = () => {
 const runLspCommand = () => flatMap$4(ToolCommands, (tools) => tools.lsp(selfGtd()));
 /**
 * Prints the briefing, emitted by the binary itself so it's always current.
-* At a repository root no `gtd.config.ts` governs yet, it also writes one
-* importing gtd's shipped workflows, left uncommitted.
-* Anywhere else it writes nothing.
+* gtd ships no workflow, so where no `gtd.config.ts` governs it says where to
+* get one; it writes nothing.
 */
 const runInstallCommand = (out) => gen(function* () {
 	const briefing = renderBriefing();
@@ -42027,8 +42047,7 @@ const runInstallCommand = (out) => gen(function* () {
 	if (topLevel._tag === "Left") return;
 	if ((yield* host.realPath(topLevel.right)) !== (yield* host.realPath(host.root))) return;
 	if ((yield* (yield* ConfigDiscovery).workflowModule(host.root, host.home)) !== void 0) return;
-	yield* (yield* Workspace).write(WORKFLOW_MODULE, CONFIG_SCAFFOLD);
-	yield* (yield* Narrator).warn(`gtd install: wrote ${WORKFLOW_MODULE}, importing gtd's shipped workflows — commit it before your first \`gtd land\``);
+	yield* (yield* Narrator).warn(`gtd install: no ${WORKFLOW_MODULE} governs here, and gtd ships no workflow — get one from ${WORKFLOWS_REPO} or write your own (step 2 of the briefing above)`);
 });
 /**
 * Exactly one trailing newline — duplicated from `Cli.ts`'s own
@@ -43086,10 +43105,8 @@ const COMMAND_ROWS = [
 			"agent (or a human) to build a gtd driver in any shell or",
 			"runtime — the self-serve version of",
 			"https://github.com/pmelab/gtd/blob/main/docs/driver.md's",
-			"'Writing your own driver'. At a repository root no",
-			"gtd.config.ts governs yet, it also writes one importing each",
-			"shipped workflow from @pmelab/gtd/workflows/<name>; anywhere",
-			"else it writes nothing."
+			"'Writing your own driver', and how to get a workflow: gtd",
+			"ships none. It writes nothing."
 		]
 	},
 	{

package/dist/testkit/gherkin.mjs

@@ -1,4 +1,4 @@
-import { n as testRepo, t as runsItsScript } from "../chunks/testkit-JDtpNKyi.mjs";
+import { n as testRepo, t as runsItsScript } from "../chunks/testkit-CMBAAyRK.mjs";
 import { resolve } from "node:path";
 import assert from "node:assert";
 import { pathToFileURL } from "node:url";

package/dist/testkit.mjs

@@ -1,2 +1,2 @@
-import { n as testRepo, r as InMemRepo, t as runsItsScript } from "./chunks/testkit-JDtpNKyi.mjs";
+import { n as testRepo, r as InMemRepo, t as runsItsScript } from "./chunks/testkit-CMBAAyRK.mjs";
 export { InMemRepo, runsItsScript, testRepo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "58.2.0",
+  "version": "59.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -27,41 +27,6 @@
       "source": "./src/workflow-kit/index.ts",
       "default": "./dist/workflow-kit.mjs"
     },
-    "./workflows": {
-      "types": "./src/workflows/index.ts",
-      "source": "./src/workflows/index.ts",
-      "default": "./dist/workflows.mjs"
-    },
-    "./workflows/feature": {
-      "types": "./src/workflows/feature/index.ts",
-      "source": "./src/workflows/feature/index.ts",
-      "default": "./dist/workflows/feature.mjs"
-    },
-    "./workflows/review": {
-      "types": "./src/workflows/review/index.ts",
-      "source": "./src/workflows/review/index.ts",
-      "default": "./dist/workflows/review.mjs"
-    },
-    "./workflows/fix": {
-      "types": "./src/workflows/fix/index.ts",
-      "source": "./src/workflows/fix/index.ts",
-      "default": "./dist/workflows/fix.mjs"
-    },
-    "./workflow": {
-      "types": "./src/workflows/index.ts",
-      "source": "./src/workflows/index.ts",
-      "default": "./dist/workflows.mjs"
-    },
-    "./workflows/rollout": {
-      "types": "./src/workflows/rollout/index.ts",
-      "source": "./src/workflows/rollout/index.ts",
-      "default": "./dist/workflows/rollout.mjs"
-    },
-    "./workflows/cleanup": {
-      "types": "./src/workflows/cleanup/index.ts",
-      "source": "./src/workflows/cleanup/index.ts",
-      "default": "./dist/workflows/cleanup.mjs"
-    },
     "./testkit": {
       "types": "./src/testkit/index.ts",
       "source": "./src/testkit/index.ts",
@@ -76,7 +41,6 @@
   "files": [
     "dist/",
     "src/flows/",
-    "src/workflows/",
     "src/workflow-kit/",
     "src/wire/",
     "src/steering/",
@@ -119,7 +83,7 @@
   "scripts": {
     "prepare": "husky",
     "dev": "node dev/run.mjs",
-    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd && tsdown --filter workflows && tsdown --filter entrypoints",
+    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd && tsdown --filter entrypoints",
     "postbuild": "node scripts/assert-no-test-doubles.mjs",
     "watch": "tsdown --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
@@ -141,9 +105,7 @@
     "analyze": "fallow --summary --quiet",
     "test:web": "vitest run --project storybook",
     "storybook": "storybook dev --host 0.0.0.0",
-    "coverage": "vitest run --project unit --coverage",
-    "eval": ": \"${GTD_EVALS_URL:?GTD_EVALS_URL is required — the OpenAI-compatible gateway every graded turn and the judge run through}\" && : \"${GTD_EVALS_KEY:?GTD_EVALS_KEY is required — the gateway bearer key}\" && npx turbo run build && node evals/eval.mjs",
-    "eval:baseline": "node evals/compare-baseline.mjs --record"
+    "coverage": "vitest run --project unit --coverage"
   },
   "lint-staged": {
     "*": "oxfmt --no-error-on-unmatched-pattern --write"
@@ -184,7 +146,6 @@
     "oxlint": "^1.74.0",
     "playwright": "^1.62.1",
     "prettier": "^3.8.1",
-    "promptfoo": "0.122.1",
     "quickpickle": "1.11.2",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",

package/skills/authoring/SKILL.md

@@ -29,20 +29,25 @@ what a driver does.
 state (`gtd next`, `gtd lsp`, `gtd door` and `gtd doors` included). It is code
 the user's repository runs; write it with the same care as a build script.
 
-## Golden rule: start from the shipped workflows, edit incrementally
+## Golden rule: start from an existing workflow, edit incrementally
 
 Do **not** write a workflow from a blank page unless the user wants something
-tiny. gtd ships three workflows (`feature`, `review`, `fix`) as named exports of
-`@pmelab/gtd/workflows`; `gtd install` scaffolds a `gtd.config.ts` re-exporting
-them. Its default export is `feature` (the ordinary start), and every phase and
-single step they are built from is a named export too. Start by importing what
-you keep and writing only what changes. Import phases by name; **never
+tiny. gtd ships no workflow; https://github.com/pmelab/gtd-workflows does. Its
+`default` (feature, review, fix, rollout, cleanup) is used from a checkout
+pinned on the machine — `bin/gtd-wf pin` there, then `bin/gtd-wf config default`
+prints a `gtd.config.ts` importing its bundle by absolute path. Every phase and
+single step that bundle is built from is a named export too, so a config can
+import what it keeps and write only what changes. Import phases by name; **never
 `export *` from it** — every exported function of your file would become a
 startable workflow:
 
 ```ts
 import { start } from "@pmelab/gtd/flows"
-import { afterTail, buildTail, feature } from "@pmelab/gtd/workflows"
+import {
+  afterTail,
+  buildTail,
+  feature,
+} from "/home/me/.local/share/gtd/workflows/dist/default.mjs"
 
 export {
   defaults,
@@ -51,9 +56,9 @@ export {
   base,
   steering,
   skills,
-} from "@pmelab/gtd/workflows"
+} from "/home/me/.local/share/gtd/workflows/dist/default.mjs"
 
-export default feature
+export default feature()
 
 export async function hotfix() {
   return afterTail(await buildTail(start(), { fixFirst: true }))
@@ -62,21 +67,22 @@ export async function hotfix() {
 export const doors = { hotfix: { workflow: "hotfix" } }
 ```
 
-`gtd --workflow hotfix` (or `gtd door hotfix`) starts it.
+`gtd --workflow hotfix` (or `gtd door hotfix`) starts it. Use the checkout's
+real path; `gtd-wf status` shows it.
 
-To change a phase itself, read its source in the npm package
-(`node_modules/@pmelab/gtd/src/workflows/`, or under `$(npm root -g)` for a
-global install) and write your own version in `gtd.config.ts`, reusing its
-single steps.
+To change a phase itself, read its source in the checkout (`workflows/default/`)
+and either write your own version in `gtd.config.ts`, reusing its single steps,
+or copy the whole workflow in a clone of gtd-workflows
+(`bin/gtd-wf new <name> --from default`) and change it there, with its tests.
 
 There is no `extends`/merge: the innermost `gtd.config.ts` walking up from the
 current directory is the whole workflow. If one already exists, read it and edit
 it in place.
 
-Prefer the bundled workflow's own parts over re-implementing them — `healthy`,
+Prefer the workflow's own parts over re-implementing them — `healthy`,
 `escalation`, `gate`, `design`, `seamBuild`, `implement`, `qualityLap`,
 `buildTail`, and single steps like `triage` or `fixCheck`. Their full step names
-are versioned API.
+are that workflow's versioned API, not gtd's.
 
 Make one small change, **verify it loads** (see "Verify"), then make the next. A
 workflow that fails to load breaks every gtd command in the repository.
@@ -142,15 +148,15 @@ the pending landing — call it right after the step whose turn you reject.
   the last dot). Rename a step and every process resting on it diverges.
 - An episode ends when the flow returns or calls `restart()`; the next starts at
   the flow's first step on an ordinary start — that step is where a finished
-  process waits (the bundled one is `human("idle", …)`).
+  process waits (gtd-workflows' default uses `human("idle", …)`).
 - `gtd --workflow <name>` starts a process on the exported workflow `<name>` (an
   unknown name is a usage error); `gtd door <name> [args]` starts one through a
   `doors` entry `{ workflow, args?, vars? }` (`gtd doors` lists them). A
-  factory's build may return `doors` without `workflow`; exporting the bundled
-  `fix`, `review`, `rollout` and `cleanup` brings `fix`, `review [base]`,
-  `rollout <flag>` and `cleanup <flag>`, and yours merge over them. An
-  `export const base = (workflow, vars) => commitish | undefined` fixes a
-  started process's diff base (blank = default-branch merge-base).
+  factory's build may return `doors` without `workflow`; exporting
+  gtd-workflows' `fix`, `review`, `rollout` and `cleanup` brings `fix`,
+  `review [base]`, `rollout <flag>` and `cleanup <flag>`, and yours merge over
+  them. An `export const base = (workflow, vars) => commitish | undefined` fixes
+  a started process's diff base (blank = default-branch merge-base).
   `--var <name>=<value>` only pins process settings: names the workflow's
   `defaults` declare — never an environment setting.
 
@@ -222,7 +228,7 @@ workflow.
 
 ## Worked example: add an approval gate before building
 
-In the bundled default, `planAndBuild` runs the design phase, then
+In gtd-workflows' default, `planAndBuild` runs the design phase, then
 `buildFeature`: the naive pass and its seam judge, then the implementation (the
 pass itself on `land`), the quality lap and the human review (a review feedback
 lap re-runs design inside `buildFeature` and does not pass it again). Add a
@@ -260,5 +266,5 @@ process before switching to the edited workflow.
 - This skill is versioned in the gtd repository, not auto-installed. When gtd is
   upgraded, re-copy it from the new version's `skills/authoring/SKILL.md`.
 - Where this file and the code disagree, the code wins: the step API's own doc
-  comments in `@pmelab/gtd/flows`, and the bundled workflow under
-  `src/workflows/`.
+  comments in `@pmelab/gtd/flows`, and the workflow's source in its own
+  repository (gtd-workflows' `workflows/default/`).

package/src/cli/Cli.test.ts

@@ -26,7 +26,6 @@ import { EXIT_CODES, EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.
 import { Host } from "../platform/index.js"
 import { type CommandRequirements } from "./Cli.js"
 import { InMemRepo, makeCapturingCliIo, testLayers } from "../twins/index.js"
-import { CONFIG_SCAFFOLD } from "../install/index.js"
 
 const FLAG_NAMES = [
   "--json",
@@ -1291,8 +1290,9 @@ export const side = async () => {
   await agent("working", "w")
 }
 
-export const defaults = { flag_risk_tier: "0" }
+export const defaults = { flag_beta: "0" }
 `
+  const BETA = { name: "beta", owner: "pmelab", expiry: "2099-01-01", kind: "release" } as const
   const start = async (
     flags?: CliIo["flags"],
     env: Record<string, string> = {},
@@ -1307,27 +1307,23 @@ export const defaults = { flag_risk_tier: "0" }
     return result().stdout
   }
 
-  it("pins flag_risk_tier=1 with the flag on", async () => {
-    expect(await start(undefined, { GTD_FLAG_RISK_TIER: "1" })).toContain("flag_risk_tier=1")
+  it("pins flag_beta=1 with the flag on", async () => {
+    expect(await start([BETA], { GTD_FLAG_BETA: "1" })).toContain("flag_beta=1")
   })
 
   it("honours defaultOn with GTD_FLAG_* unset", async () => {
-    const out = await start(
-      [
-        {
-          name: "risk_tier",
-          owner: "pmelab",
-          expiry: "2099-01-01",
-          kind: "release",
-          defaultOn: true,
-        },
-      ],
-      { GTD_FLAG_RISK_TIER: "" },
-    )
-    expect(out).toContain("flag_risk_tier=1")
+    const out = await start([{ ...BETA, defaultOn: true }], { GTD_FLAG_BETA: "" })
+    expect(out).toContain("flag_beta=1")
   })
 })
 
+const IDLE_CONFIG = `import { human } from "@pmelab/gtd/flows"
+
+export default async () => {
+  await human("idle", { message: "hi" })
+}
+`
+
 describe("runCli — exit codes", () => {
   it("output plan: exit is never called (success) — --help and --version still exit 0", async () => {
     const { io, captured } = capturingIo(throwingLayers)
@@ -1369,7 +1365,7 @@ describe("runCli — exit codes", () => {
   it("an unknown --json=<path> selector exits EXIT_USAGE_ERROR, not EXIT_RUNTIME_ERROR — Program.ts's SelectorUsageError mapped by report()", async () => {
     const repo = new InMemRepo()
     repo.writeFile("NOTE.md", "a note\n")
-    repo.writeFile("gtd.config.ts", CONFIG_SCAFFOLD)
+    repo.writeFile("gtd.config.ts", IDLE_CONFIG)
     repo.seedCommit("gtd: init")
     const { io, captured } = capturingIo(() => testLayers(repo))
     await Effect.runPromise(runCli(["node", "gtd.js", "next", "--json=does.not.exist"], io))
@@ -1534,7 +1530,7 @@ describe("runCli — flush normalizes the artifact's trailing newline", () => {
   it("a plain-text write command's script (no trailing newline) reaches io.stdout with exactly one", async () => {
     const repo = new InMemRepo()
     repo.writeFile(".gitignore", "node_modules\n")
-    repo.writeFile("gtd.config.ts", CONFIG_SCAFFOLD)
+    repo.writeFile("gtd.config.ts", IDLE_CONFIG)
     repo.seedCommit("chore: initial commit")
     const { io, captured } = capturingIo(() => testLayers(repo))
     await Effect.runPromise(runCli(["node", "gtd.js", "land"], io))

package/src/cli/Cli.ts

@@ -578,10 +578,8 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "agent (or a human) to build a gtd driver in any shell or",
       "runtime — the self-serve version of",
       "https://github.com/pmelab/gtd/blob/main/docs/driver.md's",
-      "'Writing your own driver'. At a repository root no",
-      "gtd.config.ts governs yet, it also writes one importing each",
-      "shipped workflow from @pmelab/gtd/workflows/<name>; anywhere",
-      "else it writes nothing.",
+      "'Writing your own driver', and how to get a workflow: gtd",
+      "ships none. It writes nothing.",
     ],
   },
   {