@pmelab/gtd 60.0.0 → 61.0.0

package/src/testkit/TestRepo.test.ts

@@ -61,10 +61,12 @@ describe("testRepo", () => {
     expect(repo.subjects()).toEqual([
       "chore: initial commit",
       "gtd(agent): plan → build",
+      "gtd(check): pin → build",
       "gtd(agent): build → check",
       "gtd(check): check → sign-off",
     ])
     expect(repo.read("src/add.ts")).toContain("a + b")
+    expect(repo.read(".gtd/process.gtdpin")).toBeDefined()
   })
 
   it("runs a workflow given as gtd.config.ts source", async () => {
@@ -550,7 +552,8 @@ describe("testRepo", () => {
         trailers: { Refs: ["#1", "#2"] },
       })
       await repo.drive({ plan: (_, r) => r.write("PLAN.md", "p\n") })
-      expect(repo.commits().at(-1)!.trailers["Gtd-Step"]).toEqual(["plan#1"])
+      expect(repo.commits().at(-2)!.trailers["Gtd-Step"]).toEqual(["plan#1"])
+      expect(repo.commits().at(-1)!.trailers["Gtd-Pin"]).toEqual(["add"])
     })
 
     const greeter = {

package/src/testkit/TestRepo.ts

@@ -353,13 +353,15 @@ const expectedVerdict = (doc: BeatDocument): string => {
 
 const quoted = (names: readonly string[]): string => names.map((name) => `"${name}"`).join(", ")
 
-/** Who acts at `doc`: its scripted actor, or a check's own script under `checks: "run"`. A stall has none. */
+/** Who acts at `doc`: its scripted actor, or its own script at a pin beat or a check under `checks: "run"`. A stall has none. */
 const actorAt = (
   doc: BeatDocument,
   actors: Actors,
   checks: DriveOptions["checks"],
 ): { readonly scripted: boolean; readonly actor: ScriptedActor | undefined } => {
   if (doc.kind === "stalled") return { scripted: false, actor: undefined }
+  // A drive is a driver: pinning is its own business, not a step to script.
+  if (doc.pin !== undefined) return { scripted: false, actor: runsItsScript }
   if (Object.hasOwn(actors, doc.state)) return { scripted: true, actor: actors[doc.state] }
   const runs = checks === "run" && doc.actor === "check"
   return { scripted: false, actor: runs ? runsItsScript : undefined }

package/src/twins/EmittedScriptRecognizer.ts

@@ -7,6 +7,7 @@ import {
   commitAll,
   commitAsIs,
   commitClean,
+  commitPath,
   deleteRef,
   discardPending,
   hardResetTo,
@@ -24,6 +25,8 @@ import {
   contradictionMessage,
   modeContradictionSkipNotice,
   OUTCOME_MARKER,
+  pinScript,
+  unpinScript,
 } from "../emit/index.js"
 import {
   BUILT_IN_MODE_NAMES,
@@ -32,7 +35,7 @@ import {
   type SteeringFormat,
 } from "../steering/internal.js"
 import { refNameFault } from "../replay/index.js"
-import { renderFormat } from "../wire/index.js"
+import { PIN_PATH, renderFormat } from "../wire/index.js"
 import { applyFlowScript, rewritten } from "./FlowScripts.js"
 import type { InMemRepo } from "./InMemRepo.js"
 import type { CommandTable } from "./Layers.js"
@@ -174,6 +177,17 @@ const recognizeGitBuilders = (repo: InMemRepo, block: string): BlockOutcome | un
 
   if (block.startsWith("git add -A || exit 1\ngtd_sign_cfg=")) return recognizeKeepTurn(repo, block)
 
+  if (block.startsWith("git add -A -- ")) {
+    const [path, message] = extractQuotedTokens(block)
+    if (path === undefined || message === undefined || commitPath(path, message) !== block) {
+      return undefined
+    }
+    const failure = repo.commitPath(path, message)
+    return failure === undefined
+      ? { kind: "applied" }
+      : { kind: "failed", error: failure, status: 1 }
+  }
+
   if (block.startsWith("git add -A || exit 1\n")) {
     const [message] = extractQuotedTokens(conditionLine)
     if (message !== undefined && commitAll(message) === block) {
@@ -255,6 +269,22 @@ const recognizeGitBuilders = (repo: InMemRepo, block: string): BlockOutcome | un
   return undefined
 }
 
+/** What the in-memory `gtd bundle` prints: a pin header, and no engine behind it. */
+const IN_MEMORY_PIN = "gtdpin 1 gtd in-memory\n"
+
+/** A pin or unpin beat's script. */
+const recognizePinScripts = (repo: InMemRepo, block: string): BlockOutcome | undefined => {
+  if (block === pinScript(PIN_PATH)) {
+    repo.writeFile(PIN_PATH, IN_MEMORY_PIN)
+    return { kind: "applied" }
+  }
+  if (block === unpinScript(PIN_PATH)) {
+    if (repo.readFile(PIN_PATH) !== undefined) repo.deleteFile(PIN_PATH)
+    return { kind: "applied" }
+  }
+  return undefined
+}
+
 /** The REAL `fileExistsGuard` block, re-derived from the extracted path and string-compared. The one recognizer that can report `{ kind: "stopped" }`: a real `exit 0` there ends the script successfully. */
 const recognizeFileExistsGuard = (repo: InMemRepo, block: string): BlockOutcome | undefined => {
   const [file] = extractQuotedTokens(block)
@@ -694,6 +724,7 @@ const recognizersFor = (
   (block) => recognizeBinaryGuard(commands, block),
   (block) => (git ? recognizeGitBuilders(repo, block) : undefined),
   (block) => recognizeWriteLines(repo, block),
+  (block) => recognizePinScripts(repo, block),
   (block) => recognizeFailurePromptWrapper(repo, commands, block),
   (block) => recognizePresentationSubshell(repo, commands, block, git),
   (block) => recognizeModeContradictionSkipNotice(block),

package/src/twins/EmittedScripts.test.ts

@@ -180,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,10 +18,11 @@ 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,
+  commitPath,
+  unpinScript,
   commitAsIs,
   commitClean,
   softResetTo,
@@ -165,7 +166,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 +178,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 +1267,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 +1298,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)
@@ -1357,6 +1358,27 @@ export const runGitScriptContract = (makeTier: () => GitTier): void => {
     })
   })
 
+  describe("commitPath", () => {
+    it("commits the one path; every other pending change stays pending", () => {
+      t.seed.writeFile(".gtd/process.gtdpin", "pin")
+      t.seed.writeFile("other.ts", "export const y = 1")
+      run(t, commitPath(".gtd/process.gtdpin", "gtd(check): pin → building"))
+      expect(t.observe.headSubject()).toBe("gtd(check): pin → building")
+      expect(t.observe.headTouchedPaths()).toEqual([".gtd/process.gtdpin"])
+      expect(t.observe.statusPorcelain()).toContain("other.ts")
+      expect(t.observe.statusPorcelain()).not.toContain("process.gtdpin")
+    })
+
+    it("commits the path's deletion", () => {
+      t.seed.commit("feat: pinned", { ".gtd/process.gtdpin": "pin" })
+      run(t, unpinScript(".gtd/process.gtdpin"))
+      run(t, commitPath(".gtd/process.gtdpin", "gtd(check): unpin → idle"))
+      expect(t.observe.headTouchedPaths()).toEqual([".gtd/process.gtdpin"])
+      expect(t.observe.existsPath(".gtd/process.gtdpin")).toBe(false)
+      expect(t.observe.statusPorcelain().trim()).toBe("")
+    })
+  })
+
   describe("commitClean", () => {
     it("on a clean tree commits an empty commit with the message", () => {
       const headBefore = t.observe.resolveRef("HEAD")

package/src/twins/InMemRepo.ts

@@ -474,6 +474,20 @@ export class InMemRepo {
     this.resetHard()
   }
 
+  /** Twin of `GitScript.commitPath`: commits `path` as the worktree has it, every other staged change left staged. */
+  commitPath(path: string, message: string): string | undefined {
+    if (!this.worktree.has(path) && !this.headTree().has(path) && !this.index.has(path)) {
+      return `error: pathspec '${path}' did not match any file(s) known to git`
+    }
+    const staged = new Map(this.index)
+    this.index = new Map(this.headTree())
+    this.stage(path)
+    const failure = this.commitAsIs(message)
+    this.index = staged
+    this.stage(path)
+    return failure
+  }
+
   commitAllWithPrefix(prefix: string): string | undefined {
     this.index = new Map(this.worktree)
     return this.commitAsIs(prefix)

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/PinBeats.ts

@@ -0,0 +1,33 @@
+import { Effect } from "effect"
+import { runCli } from "../cli/index.js"
+import type { PinMark } from "../wire/index.js"
+import { makeCapturingCliIo } from "./cliIo.js"
+import { applyEmittedScript } from "./EmittedScriptRecognizer.js"
+import type { InMemRepo } from "./InMemRepo.js"
+
+const gtd = async (repo: InMemRepo, ...args: string[]) => {
+  const { io, result } = makeCapturingCliIo(repo)
+  await Effect.runPromise(runCli(["node", "gtd.js", ...args], io))
+  return result()
+}
+
+const apply = (repo: InMemRepo, script: string): void => {
+  const outcome = applyEmittedScript(repo, new Map(), script)
+  if (!outcome.ok) throw new Error(outcome.error)
+}
+
+/**
+ * Takes the pending pin or unpin beat — `mark` alone when given — the way a
+ * driver does: its script, then its landing. Whether it took one.
+ */
+export const takePinBeat = async (repo: InMemRepo, mark?: PinMark): Promise<boolean> => {
+  const next = await gtd(repo, "next", "--json")
+  if (next.exitCode !== 0) return false
+  const beat = JSON.parse(next.stdout) as { readonly pin?: PinMark; readonly content: string }
+  if (beat.pin === undefined || (mark !== undefined && beat.pin !== mark)) return false
+  apply(repo, beat.content)
+  const land = await gtd(repo, "land", "--json")
+  if (land.exitCode !== 0) throw new Error(`gtd land exited ${land.exitCode}: ${land.stderr}`)
+  apply(repo, (JSON.parse(land.stdout) as { readonly script: string }).script)
+  return true
+}

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/twins/index.ts

@@ -11,3 +11,4 @@ export { applyFlowScript } from "./FlowScripts.js"
 export { gitTiers, runGitServiceContract, runGitScriptContract, type GitTier } from "./GitTiers.js"
 export { strictGitOperations } from "./StrictGitOperations.js"
 export { fakeGitOperations } from "./FakeGitOperations.js"
+export { takePinBeat } from "./PinBeats.js"

package/src/wire/BeatDocument.ts

@@ -1,6 +1,14 @@
 import type { BeatKind, Demand, DemandSession } from "./Demand.js"
 import type { BeatStatus, NextMatch, StatusChange } from "./BeatStatus.js"
-import type { Actor, ApprovalEntry, ModelCost, StateMode, StateName, StepAccess } from "./types.js"
+import type {
+  Actor,
+  ApprovalEntry,
+  ModelCost,
+  PinMark,
+  StateMode,
+  StateName,
+  StepAccess,
+} from "./types.js"
 import { WIRE_SCHEMA } from "./constants.js"
 
 /** `gtd next --json`'s `next` key — `null` when landing would commit nothing. */
@@ -27,20 +35,30 @@ const dispatchFieldsOf = (
   readonly validate: string | undefined
   readonly skills: readonly string[] | undefined
   readonly access: StepAccess | undefined
+  readonly pin: PinMark | undefined
 } => {
+  const none = {
+    session: undefined,
+    validate: undefined,
+    skills: undefined,
+    access: undefined,
+    pin: undefined,
+  }
   switch (demand.kind) {
     case "prompt":
       return {
+        ...none,
         session: demand.session,
         validate: demand.validate,
         skills: demand.skills,
         access: demand.access,
       }
+    case "script":
+      return { ...none, pin: demand.pin }
     case "capture":
     case "message":
-    case "script":
     case "stalled":
-      return { session: undefined, validate: undefined, skills: undefined, access: undefined }
+      return none
     default:
       return assertNeverDemand(demand)
   }
@@ -57,6 +75,8 @@ export interface BeatDocument {
   readonly model: string | undefined
   readonly system: string | undefined
   readonly validate: string | undefined
+  /** On a pin or unpin beat only: what its script does to `.gtd/process.gtdpin`. */
+  readonly pin: PinMark | undefined
   readonly log: string
   readonly state: StateName
   readonly actor: Actor
@@ -76,13 +96,13 @@ export interface BeatDocument {
 }
 
 /**
- * Flatten a `Demand` plus its `BeatStatus` into the single 25-key document
+ * Flatten a `Demand` plus its `BeatStatus` into the single 26-key document
  * `gtd next --json` emits — the ONLY place the two are joined. `cost`/
  * `costByModel` are omitted together, exactly when no cost was recorded
  * (`cost <= 0`).
  */
 export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument => {
-  const { session, validate, skills, access } = dispatchFieldsOf(demand)
+  const { session, validate, skills, access, pin } = dispatchFieldsOf(demand)
   const hasCost = status.cost > 0
   return {
     schema: WIRE_SCHEMA,
@@ -94,6 +114,7 @@ export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument =
     model: status.model,
     system: status.system,
     validate,
+    pin,
     log: status.log,
     state: status.state,
     actor: status.actor,

package/src/wire/Demand.ts

@@ -1,4 +1,11 @@
-import type { Actor, ContentKind, RenderedDemandSource, StateName, StepAccess } from "./types.js"
+import type {
+  Actor,
+  ContentKind,
+  PinMark,
+  RenderedDemandSource,
+  StateName,
+  StepAccess,
+} from "./types.js"
 
 /** The whole beat vocabulary a driver acts on — what to DO with a rest, not merely whether dispatching it is safe. */
 export type BeatKind = "capture" | "message" | "script" | "prompt" | "stalled"
@@ -72,7 +79,7 @@ export interface DemandSession {
 export type Demand =
   | { readonly kind: "capture"; readonly content: string }
   | { readonly kind: "message"; readonly content: string }
-  | { readonly kind: "script"; readonly content: string }
+  | { readonly kind: "script"; readonly content: string; readonly pin?: PinMark }
   | { readonly kind: "stalled"; readonly content: string }
   | {
       readonly kind: "prompt"
@@ -91,7 +98,10 @@ export type Demand =
  * any other kind.
  */
 export const demandOf = (input: {
-  readonly rendered: Pick<RenderedDemandSource, "actor" | "content" | "state" | "skills" | "access">
+  readonly rendered: Pick<
+    RenderedDemandSource,
+    "actor" | "content" | "state" | "skills" | "access" | "pin"
+  >
   readonly kind: BeatKind
   readonly session?: DemandSession
   readonly validate?: string
@@ -102,7 +112,7 @@ export const demandOf = (input: {
   const skills =
     rendered.skills !== undefined && rendered.skills.length > 0 ? rendered.skills : undefined
   const access = rendered.access ?? { read: null, write: null }
-  return kind === "prompt"
-    ? { kind, content, session, validate, skills, access }
-    : { kind, content }
+  if (kind === "prompt") return { kind, content, session, validate, skills, access }
+  if (kind === "script" && rendered.pin !== undefined) return { kind, content, pin: rendered.pin }
+  return { kind, content }
 }

package/src/wire/constants.ts

@@ -20,3 +20,6 @@ export const renderFormat = (fmt: string, ...args: readonly string[]): string =>
 /** The first line of the landing refusal for a turn that wrote outside its `write` access — a stable marker drivers and tests grep for. */
 export const ACCESS_REFUSAL =
   "gtd land: this turn wrote outside its write access — revert these paths, then run `gtd land` again:"
+
+/** Where a process keeps its pin: the engine and workflow it runs on, as `gtd bundle` prints them. */
+export const PIN_PATH = ".gtd/process.gtdpin"

package/src/wire/types.ts

@@ -10,6 +10,9 @@ export type StateName = string
 /** The three content kinds a state can carry — exactly one per state. */
 export type ContentKind = "script" | "prompt" | "message"
 
+/** What a pin or unpin beat does to the pin; a driver may do it its own way instead of running the script. */
+export type PinMark = "add" | "remove"
+
 /** The name of a steering-file mode. Not a closed vocabulary: the valid set derives from the active definition (`BUILT_IN_MODES` plus whatever `modes:` declares). */
 export type StateMode = string
 
@@ -51,4 +54,5 @@ export interface RenderedDemandSource {
   readonly judge?: string
   readonly skills?: readonly string[]
   readonly access?: StepAccess
+  readonly pin?: PinMark
 }

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>>
@@ -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"