@pmelab/gtd 59.0.1 → 60.1.0

package/src/twins/EmittedScriptRecognizer.ts

@@ -30,7 +30,7 @@ import {
   formatFinding,
   steeringFormatFor,
   type SteeringFormat,
-} from "../steering/index.js"
+} from "../steering/internal.js"
 import { refNameFault } from "../replay/index.js"
 import { renderFormat } from "../wire/index.js"
 import { applyFlowScript, rewritten } from "./FlowScripts.js"
@@ -518,12 +518,8 @@ const recognizeGtdCheck = (repo: InMemRepo, block: string): BlockOutcome | undef
     const known = BUILT_IN_MODE_NAMES.join(", ")
     return { kind: "failed", error: `gtd check: unknown mode "${mode}" — known modes: ${known}` }
   }
-  // An ABSENT file has nothing to check and exits 0 — `runCheckCommand`'s own
-  // documented behavior. Validating `""` instead would report every "missing
-  // header" finding the format has, turning "the reviewer deleted the file"
-  // (a case the review-doc guard owns) into a script failure.
   const content = repo.readFile(file)
-  if (content === undefined) return { kind: "noop" }
+  if (content === undefined) return { kind: "failed", error: `gtd check: no such file: ${file}` }
   const findings = format.validate(content).map((finding) => formatFinding(file, finding))
   if (findings.length === 0) return { kind: "noop" }
   return {

package/src/twins/EmittedScripts.test.ts

@@ -140,8 +140,10 @@ for (const makeTier of gitTiers) {
     })
 
     describe("gtd check", () => {
-      it("passes a valid file, and an absent one", () => {
-        expect(run(script(`gtd check qa '${FILE}'`)).ok).toBe(true)
+      it("refuses an absent file, and passes a valid one", () => {
+        const absent = run(script(`gtd check qa '${FILE}'`))
+        expect(absent).toMatchObject({ ok: false, status: 1 })
+        expect(absent.output).toContain(`gtd check: no such file: ${FILE}`)
         t.seed.writeFile(FILE, "## Open Questions\n")
         expect(run(script(`gtd check qa '${FILE}'`))).toEqual({ ok: true, status: 0, output: "" })
       })
@@ -178,7 +180,7 @@ for (const makeTier of gitTiers) {
       // As a landing renders it: under `set -eu`, which a failing update-ref relies on to stop.
       const keepTurn = (ref: string, message: string) =>
         ScriptSurface.render([{ kind: "gitWrite", write: { kind: "keepTurn", ref, message } }])
-      const git = <A>(f: (g: GitService["Type"]) => Effect.Effect<A, Error>) =>
+      const git = <A>(f: (g: GitService["Service"]) => Effect.Effect<A, Error>) =>
         t.provide(Effect.flatMap(GitService, f))
       const keptTip = async () => {
         const marker = await git((g) => g.lastCommitMessage())

package/src/twins/GitTiers.ts

@@ -18,8 +18,7 @@ import { execFileSync, execSync, spawnSync } from "node:child_process"
 // `TEST_DOUBLE_SENTINEL` check.
 import { afterEach, beforeEach, describe, expect, it } from "vitest"
 import { Effect, Exit, Option } from "effect"
-import { NodeContext } from "@effect/platform-node"
-import { Narrator, GitService, Host, type GitOperations } from "../platform/index.js"
+import { Narrator, GitService, Host, type GitOperations, NodeServices } from "../platform/index.js"
 import {
   commitAll,
   commitAsIs,
@@ -165,7 +164,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
       eff.pipe(
         Effect.provide(GitService.Live),
         Effect.provide(Host.layer({ root, home: root, env: {} })),
-        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeServices.layer),
         Effect.provide(noopNarratorLayer),
       ),
     )
@@ -177,7 +176,7 @@ const makeLiveTier = (initialCommit = true): GitTier => {
       eff.pipe(
         Effect.provide(GitService.Live),
         Effect.provide(Host.layer({ root, home: root, env: {} })),
-        Effect.provide(NodeContext.layer),
+        Effect.provide(NodeServices.layer),
         Effect.provide(noopNarratorLayer),
       ),
     )
@@ -1266,7 +1265,7 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
             Effect.flatMap(GitService, (g) => g.gitDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           expect(siblingGitDir).not.toBe(mainGitDir)
@@ -1297,14 +1296,14 @@ export const runGitServiceContract = (makeTier: () => GitTier): void => {
             Effect.flatMap(GitService, (g) => g.gitCommonDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           const siblingGitDir = await Effect.runPromise(
             Effect.flatMap(GitService, (g) => g.gitDir()).pipe(
               Effect.provide(GitService.Live),
               Effect.provide(Host.layer({ root: siblingDir, home: siblingDir, env: {} })),
-              Effect.provide(NodeContext.layer),
+              Effect.provide(NodeServices.layer),
             ),
           )
           expect(siblingCommonDir).toBe(mainCommonDir)

package/src/twins/InMemRepo.ts

@@ -30,6 +30,7 @@ function makeHash(message: string, parent: string | null, tree: Map<string, stri
 export class InMemRepo {
   // Data-only marker read by no code path: embeds the sentinel in every
   // instance so a leaked object still carries it.
+  // fallow-ignore-next-line unused-class-member
   readonly testDouble = TEST_DOUBLE_SENTINEL
 
   private commits: Map<string, Commit> = new Map()

package/src/twins/Layers.test.ts

@@ -23,7 +23,7 @@ const seed = (repo: InMemRepo, dir: string, name: string, content: string): void
 
 const runDiscovery = <A>(
   repo: InMemRepo,
-  f: (d: ConfigDiscovery["Type"]) => Effect.Effect<A, Error>,
+  f: (d: ConfigDiscovery["Service"]) => Effect.Effect<A, Error>,
 ) =>
   Effect.runPromise(
     Effect.gen(function* () {

package/src/twins/Layers.ts

@@ -21,6 +21,7 @@ import {
 import {
   ConfigDiscovery,
   ConfigService,
+  EngineCore,
   LEGACY_RC_FILES,
   legacyRcDirs,
   WORKFLOW_MODULE,
@@ -30,7 +31,7 @@ import { fakeGitOperations } from "./FakeGitOperations.js"
 import { InMemRepo } from "./InMemRepo.js"
 
 // Read off the CLI's own port rather than imported from the composition root.
-type CommandRequirements = Layer.Layer.Success<ReturnType<CliIo["layers"]>>
+type CommandRequirements = Layer.Success<ReturnType<CliIo["layers"]>>
 import { ToolCommands, type CliIo } from "../cli/index.js"
 
 const toError = (e: unknown): Error => (e instanceof Error ? e : new Error(String(e)))
@@ -167,6 +168,11 @@ const makeInMemoryConfigDiscovery = (
   })
 }
 
+/** The in-memory counterpart to the shipped `gtd.core.mjs`: an ES module that needs nothing but Node. */
+const IN_MEMORY_ENGINE = `#!/usr/bin/env node
+import "node:process"
+`
+
 /** One scripted `bash` command's canned behavior, keyed by the RENDERED command string a scenario's `Given` step declares. */
 export type ScriptedCommand =
   | {
@@ -207,13 +213,13 @@ export interface TestWorldOptions {
   /** Gates `narrate` above — defaults to `true` (fires whenever a sink is given) since these tests aren't exercising `Cli.ts`'s own `--verbose` gate. `src/twins/cliIo.ts` overrides this with the real decoded flag. */
   readonly verbose?: boolean
   /** Real or fake driver and tool commands — each one left out fails when called. */
-  readonly tools?: Partial<ToolCommands["Type"]>
+  readonly tools?: Partial<ToolCommands["Service"]>
 }
 
 const missingTool = (name: string) => () =>
   Effect.fail(new Error(`gtd ${name}: ToolCommands has no test double wired into testLayers()`))
 
-const missingToolCommands: ToolCommands["Type"] = {
+const missingToolCommands: ToolCommands["Service"] = {
   ui: missingTool("ui"),
   lsp: missingTool("lsp"),
   judge: () =>
@@ -264,6 +270,7 @@ export function testLayers(
     }),
     ConfigService.Live,
     makeInMemoryConfigDiscovery(repo, root),
+    Layer.succeed(EngineCore, { source: Effect.succeed(IN_MEMORY_ENGINE) }),
     Narrator.layer(opts.narrate ?? (() => {}), opts.verbose ?? true),
     // Drivers and tools are unit-tested in their own folders; a call reaching
     // one of these is a test gap, not silence. A test opts into one via `tools`.

package/src/twins/cliIo.ts

@@ -4,6 +4,8 @@ import { testLayers } from "./Layers.js"
 
 export interface CapturedCliResult {
   readonly stdout: string
+  /** stdout as written, for a binary artifact `stdout` would decode. */
+  readonly stdoutBytes: Uint8Array
   readonly stderr: string
   readonly exitCode: number
 }
@@ -11,14 +13,14 @@ export interface CapturedCliResult {
 export const makeCapturingCliIo = (
   repo: InMemRepo,
   env: Readonly<Record<string, string | undefined>> = {},
-  tools: Partial<ToolCommands["Type"]> = {},
+  tools: Partial<ToolCommands["Service"]> = {},
 ): { readonly io: CliIo; readonly result: () => CapturedCliResult } => {
-  let stdout = ""
+  let stdout: Buffer = Buffer.alloc(0)
   let stderr = ""
   let exitCode = 0
   const io: CliIo = {
     stdout: (chunk) => {
-      stdout += chunk
+      stdout = Buffer.concat([stdout, Buffer.from(chunk)])
     },
     stderr: (chunk) => {
       stderr += chunk
@@ -32,5 +34,8 @@ export const makeCapturingCliIo = (
     layers: (verbose) =>
       testLayers(repo, { env, narrate: (line) => (stderr += line), verbose, tools }),
   }
-  return { io, result: () => ({ stdout, stderr, exitCode }) }
+  return {
+    io,
+    result: () => ({ stdout: stdout.toString("utf8"), stdoutBytes: stdout, stderr, exitCode }),
+  }
 }

package/src/wire/Script.ts

@@ -0,0 +1,11 @@
+import { WIRE_SCHEMA } from "./constants.js"
+
+/** `--json` of every command that prints a script and nothing else to decide on: abandon, restore, start, door, validate, history fetch. */
+export interface ScriptFields {
+  readonly schema: number
+  readonly script: string
+}
+
+export const scriptFields = (script: string): ScriptFields => ({ schema: WIRE_SCHEMA, script })
+
+export const renderScriptJson = (fields: ScriptFields): string => JSON.stringify(fields) + "\n"

package/src/wire/WireSchema.test.ts

@@ -9,6 +9,8 @@ import {
   landFields,
   renderBeatJson,
   renderLandJson,
+  renderScriptJson,
+  scriptFields,
   statusOf,
   WIRE_SCHEMA,
   type BeatKind,
@@ -116,6 +118,7 @@ const documents: Readonly<Record<string, string>> = {
     }),
   ),
   "judge.json": JUDGE,
+  "script.json": renderScriptJson(scriptFields("git reset --mixed ...\n")),
 }
 
 describe(`wire schema ${WIRE_SCHEMA}`, () => {

package/src/wire/golden/1/script.json

@@ -0,0 +1,4 @@
+{
+  "schema": 1,
+  "script": "git reset --mixed ...\n"
+}

package/src/wire/index.ts

@@ -6,6 +6,7 @@ export * from "./BeatStatus.js"
 export * from "./BeatDocument.js"
 export * from "./BeatPlain.js"
 export * from "./Land.js"
+export * from "./Script.js"
 export * from "./Judge.js"
 export { selectPath } from "./Select.js"
 export { resolveSession } from "./Sessions.js"

package/src/workflow/SteeringFormats.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest"
 import fc from "fast-check"
 import { isSeededValidateCommand, seededValidateCommand } from "./SteeringFormats.js"
-import { BUILT_IN_MODE_NAMES } from "../steering/index.js"
+import { BUILT_IN_MODE_NAMES } from "../steering/internal.js"
 
 describe("seededValidateCommand / isSeededValidateCommand", () => {
   it("recognizes its own seeded command for every built-in mode", () => {

package/src/workflow/compile.ts

@@ -1,7 +1,7 @@
 import { seededValidateCommand } from "./SteeringFormats.js"
-import { BUILT_IN_MODE_NAMES } from "../steering/index.js"
+import { BUILT_IN_MODE_NAMES } from "../steering/internal.js"
 import type { ModeDef } from "./Workflow.js"
-import { configProblems, type GtdConfig, type UiSettings } from "../flows/index.js"
+import { configProblems, type GtdConfig, type UiSettings } from "../flows/internal.js"
 import type { Diagnostic } from "./Diagnostic.js"
 
 export interface CompiledConfig {

package/src/workflow/discovery.test.ts

@@ -2,15 +2,14 @@ import { execSync } from "node:child_process"
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { dirname, join } from "node:path"
-import { NodeContext } from "@effect/platform-node"
 import { Effect, Layer } from "effect"
 import { afterEach, describe, expect, it } from "vitest"
-import { GitService, Host, Narrator, Workspace } from "../platform/index.js"
+import { GitService, Host, Narrator, Workspace, NodeServices } from "../platform/index.js"
 import { InMemRepo, testLayers } from "../twins/index.js"
 import { ConfigDiscovery, ConfigService } from "./index.js"
 
 // A config and the local modules it imports load the same from disk, where
-// jiti resolves them, and from an in-memory discovery, where the loader
+// rolldown resolves them, and from an in-memory discovery, where the loader
 // resolves them itself — the same workflows, the same fingerprint, the same
 // failure for a module that is not there.
 type Files = Readonly<Record<string, string>>
@@ -22,15 +21,15 @@ interface Tier {
 
 const config = (imports: string): string =>
   [
-    'import { agent, human } from "@pmelab/gtd/flows"',
+    'import { agent, human, workflow } from "@pmelab/gtd/flows"',
     imports,
     "export default async () => {",
     '  await human("idle", { message: "go" })',
     '  await agent("working", brief)',
     "}",
-    "export const named = async () => {",
+    "export const named = workflow(async () => {",
     '  await agent("working", brief)',
-    "}",
+    "})",
     "",
   ].join("\n")
 
@@ -63,7 +62,7 @@ const live = (): Tier => {
         writeFileSync(join(root, path), content)
       }
       const host = Host.layer({ root, home: root, env: {} })
-      const git = GitService.Live.pipe(Layer.provide(Layer.merge(host, NodeContext.layer)))
+      const git = GitService.Live.pipe(Layer.provide(Layer.merge(host, NodeServices.layer)))
       const workspace = Workspace.Live.pipe(Layer.provide(Layer.merge(host, git)))
       return loadWith(
         Layer.mergeAll(
@@ -121,7 +120,24 @@ for (const make of [live, inMemory]) {
       })
     })
 
-    it("leaves a specifier in a string alone, and loads a skipped require never", async () => {
+    it("imports a local module and a gtd subpath dynamically as the flow runs", async () => {
+      t = make()
+      const loaded = await t.load({
+        "gtd.config.ts": [
+          'import { human } from "@pmelab/gtd/flows"',
+          "export default async () => {",
+          '  const { WIRE_SCHEMA } = await import("@pmelab/gtd/wire")',
+          '  const { first } = await import("./first.js")',
+          "  await human(`${first}-${WIRE_SCHEMA}`)",
+          "}",
+          "",
+        ].join("\n"),
+        "first.ts": 'export const first = "idle"\n',
+      })
+      expect(Object.keys(loaded.fingerprint).sort()).toEqual(["first.ts", "gtd.config.ts"])
+    })
+
+    it("leaves a specifier in a string alone, and runs a skipped require never", async () => {
       t = make()
       const loaded = await t.load({
         "gtd.config.ts": config(
@@ -134,14 +150,15 @@ for (const make of [live, inMemory]) {
         "optional.ts": 'throw new Error("optional ran")\n',
       })
       expect(loaded.names).toEqual(["named"])
-      expect(Object.keys(loaded.fingerprint)).toEqual(["gtd.config.ts"])
+      // Bundled, so watched, though it never runs.
+      expect(Object.keys(loaded.fingerprint).sort()).toEqual(["gtd.config.ts", "optional.ts"])
     })
 
     it("fails on an import that is not there, naming it", async () => {
       t = make()
       await expect(
         t.load({ "gtd.config.ts": config('import { brief } from "./missing.js"') }),
-      ).rejects.toThrow(/Cannot find module '\.\/missing\.js'/)
+      ).rejects.toThrow(/Could not resolve '\.\/missing\.js'/)
     })
   })
 }

package/src/workflow/discovery.ts

@@ -110,18 +110,17 @@ const workflowModule = (
   })
 
 /**
- * The discovery seam — a `Context.Tag`, not part of `WorkflowFiles` (that
+ * The discovery seam — a `Context.Service`, not part of `WorkflowFiles` (that
  * port is a plain sync record for `compileWorkflow`'s own content-file-ref
  * reads; discovery is effectful and environment-dependent: `.Live` reads
  * REAL disk, so an `@inmem` scenario's fake
  * `Workspace` — a pure in-memory `Map`, no real files anywhere on disk —
  * cannot back it. `src/twins/Layers.ts` provides the in-memory
  * counterpart instead, mirroring how `Workspace`/`Host`/`GitService` already
- * each have a production and a fake layer behind one Tag.
+ * each have a production and a fake layer behind one service.
  */
-export class ConfigDiscovery extends Context.Tag("ConfigDiscovery")<
-  ConfigDiscovery,
-  ConfigDiscoveryOps
->() {
+export class ConfigDiscovery extends Context.Service<ConfigDiscovery, ConfigDiscoveryOps>()(
+  "ConfigDiscovery",
+) {
   static Live = Layer.succeed(ConfigDiscovery, { legacyRcFiles, workflowModule })
 }

package/src/workflow/index.ts

@@ -34,3 +34,4 @@ export {
   type StateName,
 } from "./Workflow.js"
 export { changedConfigFiles, contentHash, type ConfigFingerprint } from "./fingerprint.js"
+export { EngineCore, pin, readPin } from "./pin.js"