@llm4ts/shell 2.47.2 → 2.49.0

package/flows/epic-draft.js

@@ -0,0 +1,17 @@
+// Working code first, tests and validation later: the planner cuts stories without tests, coders build under one review lens and the build gates, and what was deferred is written as debt that --harden plans under the full bar (ADR 0043).
+//
+//   llm4ts run epic-draft --repo ~/demo/portal "Add the current account and wire transfers"
+//   llm4ts run epic-draft --repo ~/demo/portal -- --plan-only "…"   # write the draft plan and stop
+//   llm4ts run epic-draft --repo ~/demo/portal -- --harden          # write the tests owed, close findings
+//   llm4ts run epic-draft --repo ~/demo/portal -- --land            # land, hardened or not
+//
+// Same seats, flags and environment as epic-stories, plus --with-tests to
+// keep the test gate while drafting. After a draft run, debt.md beside the
+// plan lists each merged story's tests owed, its deferred findings and the
+// test gate's failures on the epic checkout; a settled --harden round moves
+// what it paid to debt.paid.md.
+import { runFlowMain } from "@llm4ts/runner";
+import { epicDraftOptions, parseDraftFlags } from "./lib/epic-draft.js";
+import { runEpicStories } from "./lib/epic-stories.js";
+const flags = parseDraftFlags(process.argv.slice(2));
+runFlowMain(runEpicStories({ ...epicDraftOptions(flags), argv: flags.argv }));

package/flows/lib/epic-draft.js

@@ -0,0 +1,171 @@
+// epic-draft (ADR 0043): the epic-stories spine with tests and validation
+// deferred, not dropped. A draft run plans and builds without tests, under
+// one review lens and the build gates; what it deferred is written to
+// debt.md, and `--harden` plans that debt as a round under the full bar.
+import { join } from "node:path";
+import * as Effect from "effect/Effect";
+import { Info } from "@llm4ts/flow/FlowEvents";
+import { failingLinesOf } from "@llm4ts/flow/GateTriage";
+import { countNotPlanned } from "@llm4ts/flow/RefineRound";
+import { correctnessReviewer } from "@llm4ts/flow/Review";
+import { deferredPath, EpicReport } from "@llm4ts/flow/Stories";
+import { StoryPlan } from "@llm4ts/flow/StoryPlan";
+import { structuredAndPublish } from "@llm4ts/flow/Usage";
+import { loadRounds, rubricStoryJudge, storyPlanInstructions, storyPlanJsonSchema, unitStateDirs, withoutTestGate } from "./epic-stories.js";
+export const parseDraftFlags = (argv) => {
+    const harden = argv.includes("--harden");
+    const withTests = argv.includes("--with-tests");
+    const rest = argv.filter((arg) => arg !== "--harden" && arg !== "--with-tests");
+    return { harden, withTests, argv: harden ? ["--refine", ...rest] : rest };
+};
+// ---- The draft plan ---------------------------------------------------------
+/** The epic-stories planner's rules, then the draft cut on top. */
+export const draftPlanInstructions = (epicId, guidance, orientation) => [
+    storyPlanInstructions(epicId, guidance, orientation),
+    "",
+    "Draft cut (this run is epic-draft: working code first, tests and validation in a later",
+    "hardening round). These rules override the ones above where they differ:",
+    "- No story writes or owns test files now; leave them out of `owned`.",
+    "- `acceptance` still lists two to six outcomes per story: each one is a test the hardening",
+    "  round will write, so make each checkable by an automated test.",
+    "- Prefer fewer, thinner stories: the shortest path to working code.",
+    "- Leave `testsDeferred` out: every outcome's test is owed and planned later."
+].join("\n");
+/** The draft planner: the epic-stories plan under the draft cut. */
+export const generateDraftPlan = (inputs) => structuredAndPublish(inputs.reasoning, inputs.events, `${draftPlanInstructions(inputs.epicId, inputs.guidance, inputs.orientation)}\n\nEpic:\n${inputs.brief ?? inputs.epic}`, StoryPlan, storyPlanJsonSchema).pipe(
+// The id and the epic text are ours, whatever the model echoed back.
+Effect.map((plan) => StoryPlan.make({ ...plan, epicId: inputs.epicId, epic: inputs.epic })));
+// ---- The debt ---------------------------------------------------------------
+/** What a draft unit deferred: the tests owed, the findings, the skipped test gate. */
+export const debtPath = (stateDir) => join(stateDir, "debt.md");
+/** Debt a settled hardening round consumed. */
+export const paidPath = (stateDir) => join(stateDir, "debt.paid.md");
+const merged = (plan, report) => plan.stories.filter((story) => report.stories.some((outcome) => outcome.id === story.id && outcome.status === "done"));
+export const renderDebt = (plan, report, deferred, testFailures) => [
+    `# Debt — ${plan.epicId}`,
+    "",
+    ...merged(plan, report).flatMap((story) => [
+        `## ${story.id}`,
+        "",
+        ...story.acceptance.map((outcome) => `- [ ] test: ${outcome}`),
+        ""
+    ]),
+    ...(deferred === undefined ? [] : ["## Deferred findings", "", deferred, ""]),
+    ...(testFailures === undefined
+        ? []
+        : ["## Test gate on the epic checkout (skipped while drafting)", "", testFailures, ""])
+].join("\n");
+const counted = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+/**
+ * After a draft unit: `debt.md` with the merged stories' owed tests, their
+ * deferred findings and, when the draft skipped it, one run of the test gate
+ * on the epic checkout — gates with a memory would otherwise call those
+ * failures inherited and never charge a hardening story with them.
+ */
+export const draftAfterUnit = (withTests) => (unit, report) => Effect.gen(function* () {
+    // A story whose debt a hardening round already paid owes nothing again.
+    const paid = new Set(((yield* unit.files.read(paidPath(unit.stateDir))) ?? "")
+        .split("\n")
+        .flatMap((line) => (line.startsWith("## ") ? [line.slice(3).trim()] : [])));
+    const stories = merged(unit.plan, report).filter((story) => !paid.has(story.id));
+    const findings = [];
+    for (const story of stories) {
+        const text = yield* unit.files.read(deferredPath(unit.stateDir, story.id));
+        findings.push(...(text ?? "").split("\n").filter((line) => line.startsWith("- [")));
+    }
+    const gate = withTests || unit.testGate === undefined
+        ? undefined
+        : yield* unit.testGate(unit.workDir, unit.events);
+    // The failing lines alone: a test run's whole output would crowd the planner's prompt.
+    const failing = gate === undefined || gate.issues.length === 0
+        ? []
+        : failingLinesOf(gate, [unit.workDir]).map((line) => `- ${line}`);
+    const testFailures = gate === undefined || gate.issues.length === 0
+        ? undefined
+        : (failing.length > 0 ? failing : gate.issues.map((issue) => `- ${issue.title}`)).join("\n");
+    const owed = stories.reduce((sum, story) => sum + story.acceptance.length, 0);
+    if (owed === 0 && findings.length === 0 && testFailures === undefined) {
+        return;
+    }
+    const path = debtPath(unit.stateDir);
+    yield* unit.files.writeAtomic(path, renderDebt(unit.plan, EpicReport.make({
+        ...report,
+        stories: report.stories.filter((outcome) => !paid.has(outcome.id))
+    }), findings.length === 0 ? undefined : findings.join("\n"), testFailures));
+    yield* unit.events.publish(Info.make({
+        message: `debt: ${counted(owed, "test owed", "tests owed")}, ${findings.length === 0
+            ? "no deferred findings"
+            : counted(findings.length, "deferred finding", "deferred findings")}${testFailures === undefined ? "" : ", test gate red"} — run epic-draft --harden (${path})`
+    }));
+});
+// ---- Hardening --------------------------------------------------------------
+/** The open debt lists of an epic, by state folder; empty ones are paid. */
+const openDebt = (files, epicStateDir) => Effect.gen(function* () {
+    const open = [];
+    for (const dir of yield* unitStateDirs(files, epicStateDir)) {
+        const text = (yield* files.read(debtPath(dir)))?.trim() ?? "";
+        if (text.length > 0) {
+            open.push({ dir, text });
+        }
+    }
+    return open;
+});
+/** `--harden`: the text given, then every open debt list, as the round to plan. */
+export const hardenFeedback = (epicStateDir, text, files) => Effect.gen(function* () {
+    // An open round finishes before another is planned: with text, runAction would refuse it.
+    const rounds = yield* loadRounds(files, epicStateDir).pipe(Effect.catch(() => Effect.succeed([])));
+    const last = rounds.at(-1);
+    if (last?.plan !== undefined && last.merged < last.plan.stories.length) {
+        return text;
+    }
+    const open = yield* openDebt(files, epicStateDir);
+    return open.length === 0
+        ? text
+        : [
+            "Pay this epic's draft debt: write the tests owed as deterministic tests in the house",
+            "style, make the test gate green, and close the findings that still apply.",
+            ...(text.length === 0 ? [] : ["", text]),
+            "",
+            ...open.flatMap((debt) => [debt.text, ""])
+        ].join("\n");
+});
+/** After a hardening round that settled (nothing failed or waiting), its debt is paid. */
+export const hardenAfterUnit = (unit, report) => Effect.gen(function* () {
+    if (report.count("failed") > 0 || report.count("waiting") > 0) {
+        return;
+    }
+    for (const debt of yield* openDebt(unit.files, unit.epicStateDir)) {
+        const paid = (yield* unit.files.read(paidPath(debt.dir))) ?? "";
+        yield* unit.files.writeAtomic(paidPath(debt.dir), `${paid}${debt.text}\n`);
+        yield* unit.files.writeAtomic(debtPath(debt.dir), "");
+    }
+    // What the round's planner left out is listed, never carried (ADR 0031 decision 6).
+    const notPlannedPath = join(unit.stateDir, "not-planned.md");
+    const left = countNotPlanned((yield* unit.files.read(notPlannedPath)) ?? "");
+    if (left > 0) {
+        yield* unit.events.publish(Info.make({
+            message: `harden: ${counted(left, "debt item was", "debt items were")} not planned (${notPlannedPath}); pass them to --harden as text if they still matter`
+        }));
+    }
+});
+// ---- The policy -------------------------------------------------------------
+/**
+ * The epic-stories spine with epic-draft's policy (ADR 0043). A draft defers
+ * tests and validation; `--harden` runs epic-stories' own bar over the debt.
+ */
+export const epicDraftOptions = (flags) => flags.harden
+    ? {
+        storyJudge: rubricStoryJudge,
+        refineFeedback: hardenFeedback,
+        afterUnit: hardenAfterUnit
+    }
+    : {
+        generatePlan: generateDraftPlan,
+        stories: () => ({
+            reviewers: [correctnessReviewer],
+            maxRounds: 1,
+            deferNonBlocking: true
+        }),
+        ...(flags.withTests ? {} : { selectGates: withoutTestGate }),
+        afterUnit: draftAfterUnit(flags.withTests)
+    };

package/flows/lib/epic-mvp.js

@@ -21,7 +21,7 @@ import { Story, StoryPlan } from "@llm4ts/flow/StoryPlan";
 import { commandFor, criterionTags, evidenceSourceFromEnvironment, parseJUnit, statusFromReport, testPaths } from "@llm4ts/flow/TestEvidence";
 import { structuredAndPublish } from "@llm4ts/flow/Usage";
 import { nodeProcessExecutor, ScriptUsage } from "@llm4ts/runner";
-import { storyJsonSchema, storyPlanInstructions } from "./epic-stories.js";
+import { storyJsonSchema, storyPlanInstructions, unitStateDirs } from "./epic-stories.js";
 export const parseMvpFlags = (argv) => {
     const iterate = argv.includes("--iterate");
     const review = argv.includes("--review");
@@ -83,6 +83,7 @@ export const mvpPlanInstructions = (epicId, guidance, orientation) => [
     "  `acceptance` outcome, and none depends on a parked one.",
     "- Prefer fewer, thinner stories: the thinnest end-to-end path that works.",
     "- Items an approved brief marks deferred or dropped are parked, never planned.",
+    "- Leave `testsDeferred` out: every MVP story is written test-first.",
     'Add `"later":[…]` to each story and `"parked":[…]` beside `"stories"` in the JSON.'
 ].join("\n");
 /** The MVP planner: writes `mvp-cut.json` beside the plan with the stories parked whole. */
@@ -380,20 +381,9 @@ export const mvpAfterUnit = (source) => (unit, report) => Effect.gen(function* (
 const Verdict = Schema.fromJsonString(MvpVerdict);
 const encodeVerdict = Schema.encodeSync(Verdict);
 const decodeVerdict = Schema.decodeUnknownOption(Verdict);
-/** The state folders whose verdicts the landing reads: the epic's and each round's. */
-const verdictDirs = (files, epicStateDir) => Effect.gen(function* () {
-    const dirs = [epicStateDir];
-    for (let round = 1;; round += 1) {
-        const dir = join(epicStateDir, "rounds", String(round));
-        if ((yield* files.read(join(dir, "plan.md"))) === undefined) {
-            return dirs;
-        }
-        dirs.push(dir);
-    }
-});
 /** `--land` only once the MVP is reached, in the epic and in every round. */
 export const mvpBeforeLand = (epicStateDir, files) => Effect.gen(function* () {
-    for (const dir of yield* verdictDirs(files, epicStateDir)) {
+    for (const dir of yield* unitStateDirs(files, epicStateDir)) {
         const text = yield* files.read(verdictPath(dir));
         const verdict = text === undefined ? undefined : decodeVerdict(text);
         if (verdict === undefined || Option.isNone(verdict)) {
@@ -414,7 +404,7 @@ export const mvpBeforeLand = (epicStateDir, files) => Effect.gen(function* () {
 /** `--iterate`: the text given, then every parked list of the epic as what to plan. */
 export const mvpIterateFeedback = (epicStateDir, text, files) => Effect.gen(function* () {
     const parked = [];
-    for (const dir of yield* verdictDirs(files, epicStateDir)) {
+    for (const dir of yield* unitStateDirs(files, epicStateDir)) {
         const list = yield* files.read(parkedPath(dir));
         if (list !== undefined) {
             parked.push(list);

package/flows/lib/epic-stories.js

@@ -750,7 +750,8 @@ export const storyJsonSchema = {
         readFirst: { type: "array", items: { type: "string" } },
         acceptance: { type: "array", items: { type: "string" } },
         provides: { type: "array", items: { type: "string" } },
-        testsChange: { type: "boolean" }
+        testsChange: { type: "boolean" },
+        testsDeferred: { type: "string" }
     },
     required: [
         "id",
@@ -797,6 +798,10 @@ orientation) => [
     "- `testsChange`: true only for a story whose job includes deleting, skipping or rewriting",
     "  existing tests (a migration of a test suite, a removed feature). Every other story leaves",
     "  it out: the gates fail a story that deletes a test file or adds a skip marker.",
+    "- `testsDeferred`: only for a story whose code runs nowhere but a live runtime the repository",
+    "  cannot host in a test (IBM ACE message flows and ESQL, a mainframe transaction): one",
+    "  sentence naming that runtime. The judge then does not ask it for tests. Never set it because",
+    "  tests are hard to write; every other story leaves it out and owns its test files.",
     "- `owned` sets are pairwise DISJOINT: no path prefix appears under two stories.",
     "- Shared surfaces (the kit, the theme, house rules) are never edited by a feature story. A new",
     "  shared component is its own story, and every story using it depends on it.",
@@ -998,10 +1003,15 @@ export const storyDimensions = [
  * a partial score elsewhere is a Warning a follow-up round can close.
  */
 export const judgeSeverity = (name, score) => name === "provides" || score <= 0 ? "Critical" : "Warning";
+/** The dimensions a story is held to: all of them, less `tests` when the plan deferred them. */
+export const judgedDimensionsOf = (story) => storyDimensions
+    .map((dimension) => dimension.name)
+    .filter((name) => story.testsDeferred === undefined || name !== "tests");
 const subBar = (scored, story) => ReviewResult.make({
     issues: scored.scores
-        .filter((score) => score.score <
-        (storyDimensions.find((dimension) => dimension.name === score.name)?.maxScore ?? 2))
+        .filter((score) => judgedDimensionsOf(story).includes(score.name) &&
+        score.score <
+            (storyDimensions.find((dimension) => dimension.name === score.name)?.maxScore ?? 2))
         .map((score) => ReviewIssue.make({
         severity: judgeSeverity(score.name, score.score),
         title: `judge[${story.id}]: ${score.name} scored ${score.score}`,
@@ -1009,6 +1019,13 @@ const subBar = (scored, story) => ReviewResult.make({
     })),
     summary: `judge:${story.id}`
 });
+/** What a judge is told about a story the plan exempted from tests; nothing otherwise. */
+export const testsDeferredLines = (reason) => reason === undefined
+    ? []
+    : [
+        `Tests deferred by the plan: ${reason}`,
+        "No test file is expected; do not mark any dimension down for its absence."
+    ];
 /**
  * What the story judge reads beside the diff: the story, and what every
  * story it depends on provides. Without the dependencies the judge cannot
@@ -1039,6 +1056,7 @@ export const storyJudgeQuery = (story, plan, subject = "diff") => {
         `Provides: ${story.provides.join(", ") || "(none)"}`,
         `Owned paths: ${story.owned.join(", ")}`,
         `Shared read-only: ${story.sharedReadOnly.join(", ") || "(none)"}`,
+        ...testsDeferredLines(story.testsDeferred),
         ...(dependencies.length === 0
             ? []
             : [
@@ -1266,6 +1284,16 @@ export const stallOptions = (environment) => {
 export const gateRunOptions = (environment) => ({ timeout: Duration.seconds(gateTimeoutSeconds(environment)) });
 /** The gate command that runs the tests, for the one flaky rerun; undefined when none does. */
 export const testGateCommand = (commands) => commands.find((command) => command.some((part, index) => index > 0 && /(?:^|[^a-z])(?:test|vitest|jest)/iu.test(part)));
+/** The gates less the test command (ADR 0043): a draft defers its tests, not its build. */
+export const withoutTestGate = (commands) => {
+    const test = testGateCommand(commands);
+    return test === undefined
+        ? { commands, note: "test gate: none recognised, every gate kept" }
+        : {
+            commands: commands.filter((command) => command !== test),
+            note: `test gate deferred: ${test.join(" ")}`
+        };
+};
 /**
  * How gate output reaches the coder: a capped tail, and the log's path. The
  * epic-stories coders are CLI harnesses that can open a file; an API coder
@@ -1387,6 +1415,17 @@ export const rubricStoryJudge = (context) => (story, diff, seats, subject) => ju
 // The story's own seat, not the run's: its time counts for the story.
 // And the judge seat, never the writing reasoner: a judge reads.
 seats.context.roster?.forRole("judge") ?? seats.context.judge ?? seats.context.reasoning, story, diff, context.budget, context.plan, subject);
+/** A unit's state folders, the epic's and then each planned round's (ADR 0021). */
+export const unitStateDirs = (files, epicStateDir) => Effect.gen(function* () {
+    const dirs = [epicStateDir];
+    for (let round = 1;; round += 1) {
+        const dir = join(epicStateDir, "rounds", String(round));
+        if ((yield* files.read(join(dir, "plan.md"))) === undefined) {
+            return dirs;
+        }
+        dirs.push(dir);
+    }
+});
 /** The runner options the two flags above add; empty when neither is set. */
 export const epicRunnerOptions = Effect.fn("epic-stories.runnerOptions")(function* (options, environment) {
     const judgment = options.judgmentFromEnvironment === true
@@ -1645,8 +1684,14 @@ export const runEpicStories = (options) => Effect.gen(function* () {
             scripts: yield* appScripts(files, join(input.workDir, appDir)),
             pack
         });
-        const commands = resolvedGates.commands;
-        yield* events.publish(Info.make({ message: gateListMessage(resolvedGates) }));
+        const selected = options.selectGates === undefined
+            ? undefined
+            : options.selectGates(resolvedGates.commands);
+        const commands = selected?.commands ?? resolvedGates.commands;
+        yield* events.publish(Info.make({ message: gateListMessage({ ...resolvedGates, commands }) }));
+        if (selected?.note !== undefined) {
+            yield* events.publish(Info.make({ message: selected.note }));
+        }
         // The Node the gates would run on is the one on PATH, not the one
         // the application pins; a mismatch is a red first story that says
         // nothing about Node. Ask now, and name both.
@@ -1716,10 +1761,15 @@ export const runEpicStories = (options) => Effect.gen(function* () {
                 `The application lives in ${appDir}/ — its package.json, sources and tests; the gates run there.`
             ];
         const gates = inAppDir(appDir, gatesIn(nodeProcessExecutor, events, commands, gateRunOptions(process.env)));
-        const testCommand = testGateCommand(commands);
-        const testGate = testCommand === undefined
-            ? undefined
-            : inAppDir(appDir, gatesIn(nodeProcessExecutor, events, [testCommand], gateRunOptions(process.env)));
+        const testGateOf = (from) => {
+            const testCommand = testGateCommand(from);
+            return testCommand === undefined
+                ? undefined
+                : inAppDir(appDir, gatesIn(nodeProcessExecutor, events, [testCommand], gateRunOptions(process.env)));
+        };
+        const testGate = testGateOf(commands);
+        // A policy that deferred the test gate still gets it, to run once on its own terms.
+        const unitTestGate = testGateOf(resolvedGates.commands);
         const unitContext = (work) => ({
             plan: work.plan,
             stateDir: work.stateDir,
@@ -1728,7 +1778,7 @@ export const runEpicStories = (options) => Effect.gen(function* () {
             appDir,
             files,
             events,
-            testGate
+            testGate: unitTestGate
         });
         const setupCommand = worktreeSetupCommand(process.env, pack);
         const healthUrl = serverHealthUrl(localServer, process.env);

package/flows/lib/story-board.js

@@ -17,10 +17,10 @@ import { answerKey, decideRule, decisionKey, publishBlackboardRun, runErrorToFlo
 import { cap } from "@llm4ts/flow/Context";
 import { FlowLlmError } from "@llm4ts/flow/FlowError";
 import { JudgmentObserved, publishJudgmentObserved } from "@llm4ts/flow/FlowEvents";
-import { certaintyOf, decide, judgmentOf } from "@llm4ts/flow/Judgment";
+import { certaintyOf, Decision, decide, judgmentOf } from "@llm4ts/flow/Judgment";
 import { ReviewIssue, ReviewResult } from "@llm4ts/flow/Review";
 import { dependenciesOf } from "@llm4ts/flow/StoryPlan";
-import { storyDimensions } from "./epic-stories.js";
+import { storyDimensions, testsDeferredLines } from "./epic-stories.js";
 export class StoryBrief extends Schema.Class("StoryBrief")({
     id: Schema.String,
     title: Schema.String,
@@ -29,7 +29,8 @@ export class StoryBrief extends Schema.Class("StoryBrief")({
     provides: Schema.Array(Schema.String),
     owned: Schema.Array(Schema.String),
     sharedReadOnly: Schema.Array(Schema.String),
-    dependencies: Schema.Array(Schema.Struct({ id: Schema.String, provides: Schema.Array(Schema.String) }))
+    dependencies: Schema.Array(Schema.Struct({ id: Schema.String, provides: Schema.Array(Schema.String) })),
+    testsDeferred: Schema.optionalKey(Schema.String)
 }) {
 }
 export const storyBriefOf = (story, plan) => StoryBrief.make({
@@ -45,7 +46,8 @@ export const storyBriefOf = (story, plan) => StoryBrief.make({
         : dependenciesOf(plan, story.id).flatMap((id) => {
             const dependency = plan.story(id);
             return dependency === undefined ? [] : [{ id, provides: dependency.provides }];
-        })
+        }),
+    ...(story.testsDeferred === undefined ? {} : { testsDeferred: story.testsDeferred })
 });
 // ---- Facts ------------------------------------------------------------------
 export const storyBrief = makeKey("story.brief", StoryBrief);
@@ -53,6 +55,7 @@ export const storyDiff = makeKey("story.diff", Schema.String);
 export const houseRules = makeKey("story.houseRules", Schema.String);
 export const mergeable = makeKey("story.mergeable", Schema.Boolean);
 export const issues = makeKey("story.issues", Schema.Array(ReviewIssue));
+const decisions = makeKey("story.decisions", Schema.Array(Decision));
 /** One judged answer and one decision per story dimension, keyed by the dimension's name. */
 const judged = (name) => answerKey(`judge.${name}`);
 const decided = (name) => decisionKey(`decision.${name}`);
@@ -86,6 +89,7 @@ export const stateOf = (brief, diff, rules) => [
     `Provides: ${brief.provides.join(", ") || "(none)"}`,
     `Owned paths: ${brief.owned.join(", ")}`,
     `Shared read-only: ${brief.sharedReadOnly.join(", ") || "(none)"}`,
+    ...testsDeferredLines(brief.testsDeferred),
     ...(brief.dependencies.length === 0
         ? []
         : [
@@ -122,25 +126,34 @@ export const makeStoryBoard = (policy) => {
             return answer?.type === "score" ? [d.answer.of(answer)] : [];
         })
     });
-    const decisions = dimensions.map((d) => decideRule({
+    const deciders = dimensions.map((d) => decideRule({
         name: `decide-${d.dimension.name}`,
         answer: d.answer,
         decision: d.decision,
         ...(policy === undefined ? {} : { policy })
     }));
+    // The four decisions as one fact, so the bar can also read the brief.
+    const joined = derive({
+        name: "decisions",
+        condition: all(provides.decision, scope.decision, houseStyle.decision, tests.decision),
+        produces: [decisions],
+        derive: (verdicts) => [decisions.of(verdicts)]
+    });
     const bar = derive({
         name: "bar",
-        condition: all(provides.answer, scope.answer, houseStyle.answer, tests.answer, provides.decision, scope.decision, houseStyle.decision, tests.decision),
+        condition: all(storyBrief, provides.answer, scope.answer, houseStyle.answer, tests.answer, decisions),
         produces: [mergeable, issues],
-        derive: ([a1, a2, a3, a4, v1, v2, v3, v4]) => {
+        derive: ([brief, a1, a2, a3, a4, verdicts]) => {
             const found = [];
             const answers = [a1, a2, a3, a4];
-            const verdicts = [v1, v2, v3, v4];
             dimensions.forEach((d, index) => {
                 const answer = answers[index];
                 const verdict = verdicts[index];
                 if (answer === undefined || verdict === undefined || answer.type !== "score")
                     return;
+                // The plan deferred this story's tests (it runs only in a live runtime).
+                if (d === tests && brief.testsDeferred !== undefined)
+                    return;
                 if (answer.score < passingScore) {
                     found.push(ReviewIssue.make({
                         severity: "Critical",
@@ -163,7 +176,7 @@ export const makeStoryBoard = (policy) => {
         name: "story-board",
         imports: [storyBrief, storyDiff, houseRules],
         exports: [mergeable, issues],
-        rules: [storyJudge, ...decisions, bar]
+        rules: [storyJudge, ...deciders, joined, bar]
     });
 };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llm4ts/shell",
-  "version": "2.47.2",
+  "version": "2.49.0",
   "description": "Interactive shell and CLI for llm4ts: flow discovery, run-a-flow, and view",
   "license": "MIT",
   "type": "module",
@@ -61,9 +61,9 @@
   "dependencies": {
     "@effect/platform-node": "4.0.0",
     "@effect/platform-node-shared": "4.0.0",
-    "@llm4ts/core": "2.47.2",
-    "@llm4ts/flow": "2.47.2",
-    "@llm4ts/runner": "2.47.2"
+    "@llm4ts/flow": "2.49.0",
+    "@llm4ts/core": "2.49.0",
+    "@llm4ts/runner": "2.49.0"
   },
   "peerDependencies": {
     "effect": "4.0.0"