@llm4ts/shell 0.5.0 → 0.6.1

package/flows/packs/jsp-nextjs/prompts/bdd.md

@@ -0,0 +1,12 @@
+Write Gherkin .feature files encoding the specs as executable user journeys — these
+become the acceptance tests of the new SPA.
+
+- One feature per screen/flow.
+- User vocabulary, not servlet vocabulary: "When she submits a transfer of 3000.00,
+  Then she is asked to confirm", not "doPost forwards to confirm.jsp".
+- Error messages are asserted VERBATIM — they are contract.
+- Concrete values everywhere: real account numbers, amounts, statuses.
+- Cover: each screen's happy path, EVERY validation rule and its message, threshold
+  boundaries (a rule at 2500.00 gets scenarios at 2500.00 and 2500.01 per its
+  inclusive/exclusive semantics), confirmation flows, and the state that must
+  survive navigation (what hidden fields carried).

package/flows/packs/jsp-nextjs/prompts/implement.md

@@ -0,0 +1,17 @@
+You implement one task at a time in a client-only Next.js (App Router, static
+export) SPA that replaces a J2EE/JSP application. The committed specs under
+docs/specs/ and the .feature files under features/ are the contract; the acceptance
+tests encode them — make them pass without weakening them.
+
+Non-negotiables when porting JSP semantics:
+
+- Validation error messages match the spec VERBATIM — character for character.
+- Validation runs client-side in the same order the spec numbers the rules
+  (first-failure-wins), and thresholds keep their inclusive/exclusive semantics.
+- Session attributes and hidden-field flows become explicit client state — never
+  re-derive a value the legacy app carried through a hidden field.
+- Every server interaction goes through the API client module; components never
+  call fetch directly (the tests mock that seam).
+- Money renders and compares as exact decimals — no floating-point arithmetic on
+  amounts.
+- Follow the scaffold's structure; tests stay runnable with `node --test` alone.

package/flows/packs/jsp-nextjs/prompts/plan.md

@@ -0,0 +1,14 @@
+Derive the implementation task list for the client-only Next.js SPA from the spec
+pack. Constraints:
+
+- The FIRST task must be exactly: encode the BDD scenarios as failing acceptance
+  tests under tests/ using node:test, driving the screen components/logic with the
+  expected API mocked at the fetch boundary (no production code).
+- Early tasks: the typed API client module implementing the spec's "Expected API
+  contract" (all calls go through it — it is the seam the tests mock), and shared
+  state that replaces session/hidden-field flows.
+- Then one task per screen/flow: page component, validation with VERBATIM message
+  texts, navigation, confirmation steps.
+- Each task names the spec rules (R1, ...) and scenarios it covers.
+- No server-side code: the scaffold exports statically (S3); everything dynamic
+  goes through the API client.

package/flows/packs/jsp-nextjs/prompts/review.md

@@ -0,0 +1,16 @@
+You review a finished modernization increment: a client-only Next.js SPA built from
+specs reverse-engineered out of a J2EE/JSP app. Judge the implementation against the
+committed spec pack, not your own taste.
+
+Look specifically for:
+
+- Message drift: validation texts that differ from the spec's verbatim messages.
+- Rule reordering or boundary drift (2500.00 inclusive vs exclusive).
+- Session/hidden-field state that silently disappeared — flows that "work" only
+  because a value is re-fetched or guessed.
+- Direct fetch calls bypassing the API client seam, or API shapes that diverge from
+  the spec's expected contract.
+- Weakened tests: scenarios deleted, messages loosened to regex, boundaries moved.
+
+Classify each finding as FIX (violates the spec) or IMPROVEMENT (compliant but
+worth a follow-up).

package/flows/packs/jsp-nextjs/prompts/spec.md

@@ -0,0 +1,26 @@
+Write one behavioural spec per screen/servlet cluster as Markdown with exactly these
+sections:
+
+# <Screen or flow> — <one-line purpose>
+
+## Overview
+What the user does here, entry url-pattern(s), where it navigates.
+
+## Screens
+What each page shows (fields, per-row rendering, status label mappings), forms and
+their fields (including hidden fields), links.
+
+## Business rules
+Numbered (R1, R2, ...), in the order the servlet applies them: validation rules with
+their EXACT error message texts, thresholds (with boundary semantics), confirmation
+steps, and what each successful action writes (table, columns, values).
+
+## Session & state
+What lives in the session, what rides in hidden fields, timeout behaviour.
+
+## Expected API contract
+The endpoints a client-only SPA needs to replace the servlet behaviour (method,
+path, request/response shape) — derived from the data access, not invented UX.
+
+## Open questions
+Anything ambiguous in the source. Empty if none.

package/flows/packs/jsp-nextjs/reviewers/traceability.md

@@ -0,0 +1,13 @@
+You are the traceability reviewer for a spec-driven modernization. Every behavioural
+change must be traceable to the committed spec pack.
+
+Flag as Critical:
+- Production behaviour with no corresponding spec rule (R-number) or BDD scenario —
+  either the spec pack is incomplete or the change is out of scope.
+- Changes to .feature files or acceptance tests that alter expected values or delete
+  scenarios (the contract must not be edited to fit the code).
+
+Flag as Warning:
+- Commits/tasks that do not state which spec rules they cover.
+
+Ignore refactors with no behavioural surface.

package/flows/packs/jsp-nextjs/reviewers/ux-fidelity.md

@@ -0,0 +1,16 @@
+---
+files: .*\.(js|jsx|ts|tsx)
+---
+You are the UX-fidelity reviewer for a JSP-to-SPA port. Your single concern: does
+the SPA preserve the exact user-observable behaviour the specs carried over?
+
+Flag as Critical:
+- Validation error messages differing from the spec text in ANY character.
+- Validation rules running in a different order than the spec's numbering, or
+  threshold boundaries drifting (>= where the spec says >).
+- Confirmation steps skipped, auto-submitted, or gated on different amounts.
+- Legacy session/hidden-field state not represented in explicit client state.
+- Floating-point arithmetic on money.
+
+Ignore styling, component structure, and framework idioms — other reviewers own
+those.

package/flows/patterns/PAT-COBOL-001-comp3-money.md

@@ -0,0 +1,7 @@
+---
+match: COMP-3|COMPUTE .* ROUNDED
+---
+COBOL packed-decimal money (COMP-3) maps to BigDecimal with scale 2; COMPUTE ROUNDED
+is RoundingMode.HALF_UP. Never float/double for amounts, rates, or balances; scale is
+part of the contract (S9(5)V99 means exactly 2 decimals). Trap: intermediate COMPUTE
+results keep COBOL truncation rules — round only where the source says ROUNDED.

package/flows/patterns/PAT-COBOL-002-redefines.md

@@ -0,0 +1,7 @@
+---
+match: REDEFINES
+---
+A REDEFINES clause is two interpretations of one buffer. Map to a sealed interface
+with one variant per interpretation and an explicit discriminator — never two mutable
+views of shared state. Trap: the discriminator is often implicit in which paragraph
+reads the field; the spec must name it.

package/flows/patterns/PAT-COBOL-003-88-levels.md

@@ -0,0 +1,7 @@
+---
+match: ^ {10,}88  
+---
+Level-88 condition names are the domain vocabulary: map each group to a Java enum
+(ACCT-STATUS 88s → AccountStatus.ACTIVE/FROZEN/CLOSED/DORMANT) and keep the raw code
+as the enum field. Trap: several 88s can overlap one value range — model predicates,
+not just constants, when ranges appear.

package/flows/patterns/PAT-COBOL-004-perform-thru.md

@@ -0,0 +1,7 @@
+---
+match: PERFORM .* THRU|GO TO .*-EXIT
+---
+PERFORM…THRU with GO TO <para>-EXIT is early-exit control flow: map to a method with
+early returns (or a validation chain), one method per performed range. Trap: a GO TO
+that escapes its PERFORM range is a latent fall-through bug in the original — flag it
+in the spec instead of reproducing it.

package/flows/patterns/PAT-COBOL-005-file-status.md

@@ -0,0 +1,6 @@
+---
+match: FILE STATUS
+---
+FILE STATUS codes are typed I/O outcomes: 00 ok, 10 EOF, others errors. Map the
+handled codes to the value channel (sealed result), unexpected ones to exceptions.
+Trap: an unchecked OPEN status in the source is a silent-failure path — surface it.

package/flows/patterns/PAT-COBOL-006-sqlcode.md

@@ -0,0 +1,7 @@
+---
+match: SQLCODE
+---
+The SQLCODE ladder (0 / +100 / other) maps to Optional-plus-typed-error: +100 is
+Optional.empty (not found), 0 is a value, anything else is an exception. Trap:
+WHENEVER clauses and per-statement EVALUATEs can differ per call site — port each
+site as it is, not one global policy.

package/flows/patterns/PAT-COBOL-007-validation-order.md

@@ -0,0 +1,7 @@
+---
+match: GO TO .*-EXIT|EVALUATE TRUE
+---
+First-failure-wins validation ladders are contract: port as an ordered chain where
+the first failing rule short-circuits with its exact reason code. Property to keep:
+at most ONE reject reason per input, and its code is the first violated rule in
+source order.

package/flows/patterns/PAT-COBOL-008-zoned-decimal.md

@@ -0,0 +1,6 @@
+---
+match: PIC S9\([0-9]+\)V99(?! +COMP)
+---
+Zoned-decimal DISPLAY amounts (overpunched sign) are a wire format: parse at the
+boundary into BigDecimal, serialize back only at the edge. Trap: sign overpunch
+conventions differ (EBCDIC { A-I / } J-R); never let the raw bytes leak inland.

package/flows/patterns/PAT-COBOL-009-occurs-table.md

@@ -0,0 +1,6 @@
+---
+match: OCCURS
+---
+OCCURS tables are fixed-capacity lists: map to List<T> with the capacity as a
+validated invariant, not an array with sentinel rows. Trap: DEPENDING ON means the
+effective size is data — carry it, do not scan for blanks.

package/flows/patterns/PAT-COBOL-010-copybook-record.md

@@ -0,0 +1,7 @@
+---
+match: ^ {6,}COPY  *[A-Z]
+---
+One copybook = one record type shared across programs: generate a single Java record
+per copybook and reuse it, mirroring COPY REPLACING prefixes as field-identical
+wrapper types. Trap: two programs copying the same book may honor different subsets
+of fields — the SPEC, not the layout, says which fields are behaviour.

package/flows/patterns/PAT-COBOL-011-batch-counters.md

@@ -0,0 +1,6 @@
+---
+match: ADD 1 TO WS-.*(COUNT|CNT)
+---
+Run counters and totals (read/posted/rejected/fees) are the batch run report: map to
+an immutable RunSummary the use case returns, not logging. The summary is observable
+behaviour when the source DISPLAYs it — keep field-for-field parity.

package/flows/patterns/PAT-COBOL-012-commit-frequency.md

@@ -0,0 +1,7 @@
+---
+match: COMMIT
+---
+COMMIT every N records is restart-safety, not business logic: in the target, one
+transaction per unit of work (per transfer) replaces chunked commits, and the spec
+notes the difference. Trap: never reproduce partial-batch visibility as behaviour —
+it was an artifact of the mainframe transaction monitor.

package/flows/patterns/PAT-COBOL-013-abend.md

@@ -0,0 +1,6 @@
+---
+match: ABEND|ILBOABN0|RETURN-CODE
+---
+ABEND U-codes and RETURN-CODE are process-exit contract with the scheduler: map to
+typed exceptions caught at the entrypoint that set the process exit status. Keep the
+distinction: expected rejects are data, ABENDs are crashes.

package/flows/patterns/PAT-COBOL-014-reject-file.md

@@ -0,0 +1,6 @@
+---
+match: REJECT
+---
+A reject file with code+reason is a first-class output: map to a reject record
+entity (code, reason, original payload) written through a port, with codes verbatim.
+The reject set is closed — port it as an enum and cover every code with a test.

package/flows/patterns/PAT-COBOL-015-accept-date.md

@@ -0,0 +1,6 @@
+---
+match: ACCEPT .* FROM DATE
+---
+ACCEPT FROM DATE is ambient time: inject a Clock; the run date is a parameter of the
+use case, never LocalDate.now() inline. This is what makes replay/equivalence
+deterministic.

package/flows/patterns/PAT-COBOL-016-string-building.md

@@ -0,0 +1,6 @@
+---
+match: STRING .*DELIMITED
+---
+STRING…DELIMITED builds fixed-format text: map to an explicit formatter with the
+exact widths/delimiters, tested against golden strings. Trap: DELIMITED BY SIZE vs
+BY SPACE differ on trailing blanks — match the source.

package/flows/patterns/PAT-COBOL-017-cursor-loop.md

@@ -0,0 +1,6 @@
+---
+match: DECLARE .* CURSOR|FETCH 
+---
+DB2 cursor loops map to pageable repository queries or streams; the loop body is a
+per-row use case. Trap: cursors see uncommitted own-writes under the same unit of
+work — if the source relies on that, the spec must say so explicitly.

package/flows/patterns/PAT-COBOL-018-yn-switches.md

@@ -0,0 +1,6 @@
+---
+match: PIC X\(0?1\).*VALUE '[YN]'
+---
+X(1) Y/N switches are booleans with domain names: WS-OD-TRIGGERED → boolean
+odFeeDue. Keep the original flag name in a comment or mapping doc for traceability.
+Trap: some are tri-state in practice (space = unknown) — check every writer first.

package/flows/patterns/PAT-COBOL-019-shared-accumulators.md

@@ -0,0 +1,6 @@
+---
+match: DAILY.*ACCUM|ACCUM.*DAILY
+---
+Accumulators maintained across programs (daily transfer totals reset by another job)
+are shared domain state: model as an explicit entity with named reset semantics, and
+document WHICH process resets it — the invariant lives between programs.

package/flows/patterns/PAT-COBOL-020-tiered-fees.md

@@ -0,0 +1,7 @@
+---
+match: FEE
+---
+Threshold fee ladders (flat under X, percent capped over) are a policy value object:
+one pure function amount→fee, boundary semantics exactly as the source (< vs <=),
+tested at each boundary and cap. Trap: waivers (same-customer) are part of the
+policy, not the caller.

package/flows/patterns/PAT-COBOL-021-overdraft-floor.md

@@ -0,0 +1,7 @@
+---
+match: OD-FLOOR|OVERDRAFT
+---
+Overdraft floors including fees are guard clauses with exact arithmetic: compute the
+post-transaction balance INCLUDING all fees the source includes before comparing to
+the floor. Trap: the OD fee itself may count against the floor — read the COMPUTE
+order, not the comment.

package/flows/patterns/PAT-COBOL-022-jcl-job-net.md

@@ -0,0 +1,6 @@
+---
+match: ^//[A-Z0-9]+ +EXEC
+---
+A JCL job is an orchestration: each EXEC step maps to a use-case invocation, COND
+codes to conditional continuation, DD statements to the step's ports. The job net
+belongs in the orchestrator (scheduler config), never hidden inside one service.

package/flows/patterns/PAT-COBOL-023-sort-step.md

@@ -0,0 +1,6 @@
+---
+match: SORT 
+---
+DFSORT steps are contract about processing ORDER: map to repository ORDER BY (or an
+explicit sort at the boundary) and record WHY the order matters — usually a control
+break downstream. Trap: sort keys include type/sign quirks of the raw record.

package/flows/patterns/PAT-COBOL-024-fixed-width-records.md

@@ -0,0 +1,6 @@
+---
+match: RECORD CONTAINS|RECORDING MODE
+---
+Fixed-width record layouts (LRECL) are wire formats: one explicit parser/serializer
+per layout at the boundary, tested against byte-exact golden records; inland types
+are domain records. Never index into strings mid-service.

package/flows/patterns/PAT-COBOL-025-audit-rows.md

@@ -0,0 +1,6 @@
+---
+match: AUDIT
+---
+One audit row per posted action is compliance behaviour: write the audit entity in
+the SAME transaction as the mutation it records, field-for-field per the spec.
+Missing audit rows are a spec violation, not an optimization.

package/flows/sdd.js

@@ -0,0 +1,114 @@
+// Spec-driven development: write a specification, encode it as red tests, implement to green.
+import { join } from "node:path";
+import * as Effect from "effect/Effect";
+import { makeChat } from "@llm4ts/flow/Chat";
+import { FlowAborted } from "@llm4ts/flow/FlowError";
+import { Plan, defaultPlanPath } from "@llm4ts/flow/Plan";
+import { implementTaskLoop, stage } from "@llm4ts/flow/PlanExecution";
+import { defaultPlanInstructions, planFrom, writeBrief } from "@llm4ts/flow/Planner";
+import { makePlanStore } from "@llm4ts/flow/Persistence";
+import { lintCommand, minimalReviewers, reviewAndFixLoop } from "@llm4ts/flow/Review";
+import { asReadOnly, coderFromEnv, gemini, withModel } from "@llm4ts/runner/Connectors";
+import { resolveFlowInput } from "@llm4ts/runner/FlowArgs";
+import { runFlowMain, runNode } from "@llm4ts/runner/FlowRunner";
+import { nodePlainFileStore } from "@llm4ts/runner/NodePlainFileStore";
+import { nodeProcessExecutor } from "@llm4ts/runner/NodeProcessExecutor";
+const proModel = process.env.LLM4TS_REASONING_MODEL ?? "gemini-3-pro-preview";
+const flashModel = process.env.LLM4TS_CODER_MODEL ?? "gemini-2.5-flash";
+const specInstructions = [
+    "Turn the change request into a precise repository specification with context, goals,",
+    "non-goals, and a numbered list of testable Given/When/Then acceptance criteria.",
+    "Explore the repository as needed. Return Markdown prose, not a task list."
+].join("\n");
+const planInstructions = [
+    defaultPlanInstructions,
+    "",
+    "The request below is a specification with numbered acceptance criteria.",
+    "The first task must encode those criteria as tests without changing production code.",
+    "Every later task implements production behavior toward making those tests pass."
+].join("\n");
+const verificationFailure = (result) => FlowAborted.make({
+    message: [
+        "acceptance criteria not met:",
+        ...result.issues.map((issue) => `${issue.title}\n${issue.description}`)
+    ].join("\n\n")
+});
+const program = Effect.gen(function* () {
+    const input = yield* resolveFlowInput("Add due dates, mark overdue items in list output, and show items due today.");
+    const explicitCoder = process.env.LLM4TS_CODER?.trim();
+    const coder = explicitCoder === undefined || explicitCoder.length === 0
+        ? withModel(gemini, flashModel)
+        : coderFromEnv(process.env);
+    const reasoning = explicitCoder === undefined || explicitCoder.length === 0
+        ? asReadOnly(withModel(gemini, proModel))
+        : asReadOnly(coder);
+    const reviewer = explicitCoder === undefined || explicitCoder.length === 0
+        ? asReadOnly(withModel(gemini, flashModel))
+        : asReadOnly(coder);
+    const store = makePlanStore(nodePlainFileStore);
+    const planPath = join(input.workDir, defaultPlanPath(input.prompt));
+    yield* runNode({
+        workDir: input.workDir,
+        workspace: input.workspace,
+        userPrompt: input.prompt,
+        coder,
+        reasoning,
+        reviewers: [reviewer],
+        environment: process.env
+    }, (context) => Effect.gen(function* () {
+        const plan = yield* stage(context.events, "specification and plan", store.recoverOrCreate(planPath, Effect.gen(function* () {
+            const spec = yield* writeBrief(context.reasoning, input.prompt, specInstructions);
+            const planned = yield* planFrom(context.reasoning, spec, planInstructions);
+            return Plan.make({ ...planned, brief: spec });
+        })));
+        const spec = plan.brief === undefined || plan.brief.length === 0
+            ? yield* writeBrief(context.reasoning, input.prompt, specInstructions)
+            : plan.brief;
+        const planWithSpec = plan.brief === undefined || plan.brief.length === 0
+            ? Plan.make({ ...plan, brief: spec })
+            : plan;
+        if (planWithSpec !== plan) {
+            yield* store.save(planPath, planWithSpec);
+        }
+        yield* stage(context.events, "branch", context.git.checkoutOrCreate(planWithSpec.epicId));
+        const specPath = join(input.workDir, `specs/${planWithSpec.epicId}.md`);
+        yield* stage(context.events, "commit specification", nodePlainFileStore
+            .read(specPath)
+            .pipe(Effect.flatMap((existing) => existing === undefined
+            ? nodePlainFileStore
+                .writeAtomic(specPath, `${spec}\n`)
+                .pipe(Effect.andThen(context.git.commitAll(`${planWithSpec.epicId}: specification`)), Effect.asVoid)
+            : Effect.void)));
+        const coderChat = yield* makeChat(context.coder, {
+            system: "Implement one task at a time. The committed specification is the contract; do not weaken its tests."
+        });
+        const testGate = lintCommand(nodeProcessExecutor, context.events, ["mvn", "-q", "test"], input.workDir);
+        const compileGate = lintCommand(nodeProcessExecutor, context.events, ["mvn", "-q", "test-compile"], input.workDir);
+        const firstTitle = planWithSpec.tasks[0]?.title;
+        yield* implementTaskLoop(store, context.events, planPath, planWithSpec, (task) => Effect.gen(function* () {
+            const testsTask = task.title === firstTitle;
+            yield* coderChat.ask(planWithSpec.taskPrompt(task));
+            yield* reviewAndFixLoop({
+                reviewers: minimalReviewers,
+                reviewerService: context.reviewers[0] ?? context.reasoning,
+                coder: coderChat,
+                taskTitle: task.title,
+                currentDiff: context.git.diffAll,
+                events: context.events,
+                lint: testsTask ? compileGate : testGate,
+                parallelism: 1
+            });
+            if (testsTask) {
+                const red = yield* testGate;
+                if (red.isClean) {
+                    return yield* FlowAborted.make({
+                        message: "the new tests pass before implementation; the specification is not encoded by a red test"
+                    });
+                }
+            }
+            yield* context.git.commitAll(`${planWithSpec.epicId}: ${task.title}`);
+        }));
+        yield* stage(context.events, "verify acceptance criteria", Effect.flatMap(testGate, (result) => result.isClean ? Effect.void : Effect.fail(verificationFailure(result))));
+    }));
+});
+runFlowMain(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llm4ts/shell",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Interactive shell and CLI for llm4ts: flow discovery, run-a-flow, and view",
   "license": "MIT",
   "type": "module",
@@ -49,9 +49,10 @@
   ],
   "dependencies": {
     "@effect/platform-node": "^4.0.0-beta.102",
-    "@llm4ts/core": "0.5.0",
-    "@llm4ts/flow": "0.5.0",
-    "@llm4ts/runner": "0.5.0"
+    "@llm4ts/flow": "0.6.1",
+    "@llm4ts/runner": "0.6.1",
+    "@llm4ts/modernize": "0.6.1",
+    "@llm4ts/core": "0.6.1"
   },
   "peerDependencies": {
     "effect": "^4.0.0-beta.102"

package/src/Cli.ts

@@ -76,14 +76,14 @@ export const renderFlowList = (
 
 /**
  * Resolves a flow argument to a runnable script path: an explicit path (a
- * value containing a separator or ending in `.ts`) is used as-is, anything
- * else is looked up by name in the discovery listing.
+ * value containing a separator or ending in `.ts`/`.js`) is used as-is,
+ * anything else is looked up by name in the discovery listing.
  */
 export const resolveFlow = Effect.fn("@llm4ts/shell/Cli.resolveFlow")(function* (
   reference: string,
   tiers: FlowTierPaths
 ) {
-  if (reference.includes("/") || reference.endsWith(".ts")) {
+  if (reference.includes("/") || reference.endsWith(".ts") || reference.endsWith(".js")) {
     const fs = yield* FileSystem
     const exists = yield* fs.exists(reference).pipe(Effect.orElseSucceed(() => false))
     if (!exists) {
@@ -115,6 +115,12 @@ const runCommand = Command.make(
       Argument.variadic(),
       Argument.withDescription("Task text passed to the flow")
     ),
+    repo: Flag.string("repo").pipe(
+      Flag.optional,
+      Flag.withDescription(
+        "Repository to run against, forwarded to the flow as --repo (defaults to the current directory)"
+      )
+    ),
     verbose: Flag.boolean("verbose").pipe(Flag.withDescription("Stream verbose flow output"))
   },
   (config) =>
@@ -127,7 +133,10 @@ const runCommand = Command.make(
       }
       const exitCode = yield* launchFlow({
         flowPath,
-        taskArgs: config.task,
+        taskArgs: [
+          ...(config.repo._tag === "Some" ? ["--repo", config.repo.value] : []),
+          ...config.task
+        ],
         environment
       })
       yield* Effect.sync(() => {

package/src/FlowCatalog.ts

@@ -62,6 +62,11 @@ export const defaultTierPaths = (options: {
 
 const tierOrder: ReadonlyArray<FlowTier> = ["project", "global", "builtin"]
 
+// User-authored flows are .ts (launched with type stripping); the built-in
+// tier ships .js because Node refuses to strip types under node_modules.
+const flowExtension = (entry: string): string | undefined =>
+  entry.endsWith(".ts") ? ".ts" : entry.endsWith(".js") ? ".js" : undefined
+
 const listTier = Effect.fn("@llm4ts/shell/FlowCatalog.listTier")(function* (
   tier: FlowTier,
   directory: string
@@ -70,14 +75,15 @@ const listTier = Effect.fn("@llm4ts/shell/FlowCatalog.listTier")(function* (
   const entries = yield* fs.readDirectory(directory).pipe(Effect.orElseSucceed(() => []))
   const flows: Array<Omit<DiscoveredFlow, "shadows">> = []
   for (const entry of [...entries].sort()) {
-    if (!entry.endsWith(".ts")) {
+    const extension = flowExtension(entry)
+    if (extension === undefined) {
       continue
     }
     const path = join(directory, entry)
     const source = yield* fs.readFileString(path).pipe(Effect.orElseSucceed(() => ""))
     const description = parseFlowDescription(source)
     flows.push({
-      name: entry.slice(0, -".ts".length),
+      name: entry.slice(0, -extension.length),
       path,
       tier,
       ...(description === undefined ? {} : { description })

package/flows/implement.ts

@@ -1,38 +0,0 @@
-// Persistent plan: plan the task, then implement, review, and commit one task at a time.
-import { join } from "node:path"
-import * as Effect from "effect/Effect"
-import { implementPlanFlow } from "@llm4ts/flow/Flow"
-import { defaultPlanPath } from "@llm4ts/flow/Plan"
-import { planFrom } from "@llm4ts/flow/Planner"
-import { makePlanStore } from "@llm4ts/flow/Persistence"
-import { coderFromEnv } from "@llm4ts/runner/Connectors"
-import { resolveFlowInput } from "@llm4ts/runner/FlowArgs"
-import { runFlowMain, runNode } from "@llm4ts/runner/FlowRunner"
-import { nodePlainFileStore } from "@llm4ts/runner/NodePlainFileStore"
-
-const program = Effect.gen(function* () {
-  const input = yield* resolveFlowInput(
-    "Add a multiply function to the calculator, including focused tests."
-  )
-  const planPath = join(input.workDir, defaultPlanPath(input.prompt))
-  const store = makePlanStore(nodePlainFileStore)
-
-  yield* runNode(
-    {
-      workDir: input.workDir,
-      workspace: input.workspace,
-      userPrompt: input.prompt,
-      coder: coderFromEnv(process.env),
-      environment: process.env
-    },
-    (context) =>
-      implementPlanFlow(context, {
-        store,
-        planPath,
-        plan: planFrom(context.reasoning, input.prompt),
-        system: "Implement one task at a time in the current repository."
-      })
-  )
-})
-
-runFlowMain(program)