@pmelab/gtd 64.3.0 → 66.0.0

package/src/twins/InMemRepo.ts

@@ -27,6 +27,11 @@ function makeHash(message: string, parent: string | null, tree: Map<string, stri
   return sha1(`${message}\n${parent ?? "null"}\n${treeStr}`)
 }
 
+/** An executable file's content carries this prefix inside the twin, so every tree copy keeps the mode for free; only the read edges strip it. */
+const EXEC = "\u0000exec\u0000"
+const plain = (content: string): string =>
+  content.startsWith(EXEC) ? content.slice(EXEC.length) : content
+
 export class InMemRepo {
   // Data-only marker read by no code path: embeds the sentinel in every
   // instance so a leaked object still carries it.
@@ -180,6 +185,89 @@ export class InMemRepo {
     this.index = new Map(tree)
   }
 
+  /** `git switch -C <name> [<start>]`: pending changes ride along only when the tip's tree is unchanged. */
+  switchBranchTo(name: string, start?: string): void {
+    const hash = start === undefined ? this.head : this.resolveRef(start)
+    if (hash === null) throw new Error(`invalid reference: ${start ?? "HEAD"}`)
+    this.moveToBranch(name, hash, true)
+  }
+
+  /** `git switch <name>`: a pending change rides along when its path is the same in both trees. */
+  switchTo(name: string): void {
+    const hash = this.branches.get(name)
+    if (hash === undefined) throw new Error(`invalid reference: ${name}`)
+    if (hash === this.head) return this.moveToBranch(name, hash, false)
+    const from = this.headTree()
+    const to = this.getCommit(hash)?.files ?? new Map<string, string>()
+    const pending = [
+      ...new Set([...from.keys(), ...this.index.keys(), ...this.worktree.keys()]),
+    ].filter(
+      (path) =>
+        this.index.get(path) !== from.get(path) || this.worktree.get(path) !== from.get(path),
+    )
+    if (pending.some((path) => to.get(path) !== from.get(path))) {
+      throw new Error(`cannot switch to '${name}': local changes would be overwritten`)
+    }
+    const carry = (side: Map<string, string>) => {
+      const out = new Map(to)
+      for (const path of pending) {
+        const content = side.get(path)
+        if (content === undefined) out.delete(path)
+        else out.set(path, content)
+      }
+      return out
+    }
+    this.worktree = carry(this.worktree)
+    this.index = carry(this.index)
+    this.head = hash
+    this.currentBranch = name
+  }
+
+  private moveToBranch(name: string, hash: string, reset: boolean): void {
+    if (hash !== this.head) {
+      if (this.statusPorcelain().trim() !== "") {
+        throw new Error(`cannot switch to '${name}': the working tree has uncommitted changes`)
+      }
+      const tree = this.getCommit(hash)?.files ?? new Map<string, string>()
+      this.head = hash
+      this.worktree = new Map(tree)
+      this.index = new Map(tree)
+    }
+    if (reset || !this.branches.has(name)) this.branches.set(name, hash)
+    this.currentBranch = name
+  }
+
+  deleteBranch(name: string): void {
+    if (name === this.currentBranch) throw new Error(`cannot delete branch '${name}' checked out`)
+    if (!this.branches.delete(name)) throw new Error(`branch '${name}' not found`)
+  }
+
+  private remotes: Map<string, Map<string, string>> = new Map()
+
+  /** Test setup: a remote that accepts pushes. */
+  // fallow-ignore-next-line unused-class-member
+  addRemote(name: string): void {
+    this.remotes.set(name, new Map())
+  }
+
+  /** What a remote holds after pushes: ref → hash. */
+  // fallow-ignore-next-line unused-class-member
+  remoteRefs(name: string): ReadonlyMap<string, string> {
+    return this.remotes.get(name) ?? new Map()
+  }
+
+  /** `git push --force <remote> <ref>:<ref>`; returns git's complaint, or `undefined`. */
+  pushRef(remote: string, ref: string): string | undefined {
+    const there = this.remotes.get(remote)
+    if (there === undefined) {
+      return `fatal: '${remote}' does not appear to be a git repository`
+    }
+    const hash = this.resolveRef(ref)
+    if (hash === null) return `error: src refspec ${ref} does not match any`
+    there.set(ref, hash)
+    return undefined
+  }
+
   /** Refs under `prefix`, newest tip first; the commit sequence number stands in for the committer date. */
   listRefs(prefix: string): Array<{ ref: string; hash: string; date: string }> {
     return [...this.refs.entries()]
@@ -284,7 +372,8 @@ export class InMemRepo {
     if (!hash) return null
     const c = this.getCommit(hash)
     if (!c) return null
-    return c.files.get(path) ?? null
+    const content = c.files.get(path)
+    return content === undefined ? null : plain(content)
   }
 
   /**
@@ -317,7 +406,20 @@ export class InMemRepo {
 
   /** The worktree content of `path`, or `undefined` when absent. A LIVE read — never a snapshot. */
   readFile(path: string): string | undefined {
-    return this.worktree.get(path)
+    const content = this.worktree.get(path)
+    return content === undefined ? undefined : plain(content)
+  }
+
+  /** `chmod +x` / `-x` on a working-tree file. */
+  setExecutable(path: string, on: boolean): void {
+    const content = this.readFile(path)
+    if (content !== undefined) this.worktree.set(path, on ? EXEC + content : content)
+  }
+
+  /** Every path's file mode at `ref`, or in the working tree when `ref` is `undefined`. */
+  modesAt(ref: string | undefined): Map<string, string> {
+    const tree = ref === undefined ? this.worktree : this.treeAt(ref)
+    return new Map([...tree].map(([path, c]) => [path, c.startsWith(EXEC) ? "100755" : "100644"]))
   }
 
   /** True when `path` is exactly a worktree file, or a directory prefix of one (any worktree key starts with `path/`). */
@@ -473,6 +575,39 @@ export class InMemRepo {
     return undefined
   }
 
+  /** Twin of `GitScript.shipCommit`: the staged tree, with `.gtd/` as `branch` has it, onto `branch`, then the landing commit naming it. */
+  shipCommit(
+    branch: string,
+    parent: string,
+    shipMessage: string,
+    historyRef: string,
+    message: string,
+  ): string | undefined {
+    this.stageAll()
+    if (this.head === null) return "fatal: Needed a single revision"
+    if (this.signingFails) return "error: gpg failed to sign the data"
+    const kept = [...(this.commits.get(parent)?.files ?? [])]
+    const tree = new Map([
+      ...[...this.index].filter(([path]) => !path.startsWith(".gtd/")),
+      ...kept.filter(([path]) => path.startsWith(".gtd/")),
+    ])
+    const shipped = `${shipMessage}\n\nGtd-History: ${historyRef}\nGtd-Tip: ${this.head}\n`
+    const hash = makeHash(shipped, parent, tree)
+    if (this.branches.get(branch) !== parent) {
+      return `fatal: update_ref failed for ref 'refs/heads/${branch}': cannot lock ref 'refs/heads/${branch}': is at ${this.branches.get(branch) ?? "nothing"} but expected ${parent}`
+    }
+    this.commits.set(hash, {
+      hash,
+      message: shipped,
+      files: tree,
+      parent,
+      seq: this.nextSeq++,
+      signed: this.signingEnabled,
+    })
+    this.branches.set(branch, hash)
+    return this.commitAsIs(`${message}\nGtd-Shipped: ${hash}`)
+  }
+
   /** Discard every pending change, tracked or untracked: stage everything, then hard-reset (which drops the freshly-staged untracked paths too). */
   discardPending(): void {
     this.index = new Map(this.worktree)
@@ -557,7 +692,9 @@ export class InMemRepo {
   }
 
   writeFile(path: string, content: string): void {
-    this.worktree.set(path, content)
+    // A live overwrite keeps the mode.
+    const was = this.worktree.get(path)
+    this.worktree.set(path, was?.startsWith(EXEC) ? EXEC + content : content)
   }
 
   deleteFile(path: string): void {

package/src/twins/Layers.ts

@@ -119,6 +119,7 @@ export const makeInMemoryWorkspaceOps = (repo: InMemRepo, root: string): Workspa
       Effect.succeed(
         new Map([...(base !== undefined ? [base] : []), ...commits].map((h) => [h, treeOf(h)])),
       ),
+    modeSync: (ref) => repo.modesAt(ref),
     worktreeSync: () =>
       new Map(
         repo

package/src/twins/SyncIo.test.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process"
-import { mkdtempSync, realpathSync, rmSync, symlinkSync } from "node:fs"
+import { chmodSync, mkdtempSync, realpathSync, rmSync, symlinkSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { afterEach, describe, expect, it } from "vitest"
@@ -12,6 +12,7 @@ interface Tier {
   readonly root: string
   readonly uid: number | undefined
   readonly symlink: (path: string, target: string) => void
+  readonly chmod: (path: string, executable: boolean) => void
   /** Commits `files`, repository-relative, as the only change. */
   readonly commit: (files: Record<string, string>) => void
 }
@@ -29,6 +30,7 @@ const liveTier = (): Tier => {
     root,
     uid: process.getuid?.(),
     symlink: (path, target) => symlinkSync(target, path),
+    chmod: (path, executable) => chmodSync(path, executable ? 0o755 : 0o644),
     commit: (files) => {
       for (const [path, content] of Object.entries(files))
         nodeSyncIo.writeText(join(root, path), content)
@@ -48,6 +50,7 @@ const inMemTier = (): Tier => {
     root,
     uid: 501,
     symlink: io.symlink,
+    chmod: io.setExecutable,
     commit: (files) => {
       for (const [path, content] of Object.entries(files)) {
         io.writeText(`${root}/${path}`, content)
@@ -106,9 +109,9 @@ describe.each([
     symlink(`${root}/link`, "dir")
     symlink(`${root}/dangling`, "nowhere")
 
-    expect(io.stat(`${root}/dir/f`)).toEqual({ type: "file", uid })
-    expect(io.stat(`${root}/link`)).toEqual({ type: "directory", uid })
-    expect(io.lstat(`${root}/link`)).toEqual({ type: "symlink", uid })
+    expect(io.stat(`${root}/dir/f`)).toMatchObject({ type: "file", uid })
+    expect(io.stat(`${root}/link`)).toMatchObject({ type: "directory", uid })
+    expect(io.lstat(`${root}/link`)).toMatchObject({ type: "symlink", uid })
     expect(io.lstat(`${root}/missing`)).toBeUndefined()
     expect(io.stat(`${root}/dangling`)).toBeUndefined()
     expect(io.readLink(`${root}/link`)).toBe("dir")
@@ -117,6 +120,18 @@ describe.each([
     expect(() => io.realPath(`${root}/dangling`)).toThrow()
   })
 
+  it("reports the executable bit of files, kept across an overwrite", () => {
+    const { io, root, chmod } = makeTier()
+    io.writeText(`${root}/f`, "x")
+    expect(io.stat(`${root}/f`)?.executable).toBe(false)
+    chmod(`${root}/f`, true)
+    expect(io.stat(`${root}/f`)?.executable).toBe(true)
+    io.writeText(`${root}/f`, "y")
+    expect(io.lstat(`${root}/f`)?.executable).toBe(true)
+    chmod(`${root}/f`, false)
+    expect(io.stat(`${root}/f`)?.executable).toBe(false)
+  })
+
   it("reads committed content through git", () => {
     const { io, root, commit } = makeTier()
     commit({ "a.txt": "committed\n" })

package/src/twins/SyncIo.ts

@@ -15,6 +15,8 @@ const decoder = new TextDecoder("utf-8", { ignoreBOM: true })
 
 export interface InMemorySyncIo extends SyncIo {
   readonly symlink: (path: string, target: string) => void
+  /** `chmod +x` / `-x` on a file. */
+  readonly setExecutable: (path: string, on: boolean) => void
 }
 
 /**
@@ -27,6 +29,7 @@ export const inMemorySyncIo = (
   const files = new Map<string, Uint8Array>()
   const links = new Map<string, string>()
   const dirs = new Set<string>(["/"])
+  const execs = new Set<string>()
 
   /** `path` with every symlink resolved, the last component's only when `followLast`. */
   const resolve = (path: string, followLast: boolean): string => {
@@ -68,7 +71,9 @@ export const inMemorySyncIo = (
 
   const info = (path: string): FileInfo | undefined => {
     const type = typeOf(path)
-    return type === undefined ? undefined : { type, uid: opts.uid }
+    return type === undefined
+      ? undefined
+      : { type, uid: opts.uid, ...(type === "file" ? { executable: execs.has(path) } : {}) }
   }
 
   const readFile = (path: string): Uint8Array | undefined => {
@@ -136,6 +141,8 @@ export const inMemorySyncIo = (
       links.delete(target)
       files.set(target, bytes)
       files.delete(source)
+      execs.delete(target)
+      if (execs.delete(source)) execs.add(target)
     },
     stat: (path) => info(resolve(path, true)),
     lstat: (path) => info(resolve(path, false)),
@@ -152,6 +159,11 @@ export const inMemorySyncIo = (
     git,
     gitBytes: (cwd, args) => encoder.encode(git(cwd, args)),
     hash: pureHash,
+    setExecutable: (path, on) => {
+      const real = resolve(path, true)
+      if (on) execs.add(real)
+      else execs.delete(real)
+    },
     symlink: (path, target) => {
       links.set(resolve(path, false), target)
     },

package/src/wire/BeatDocument.test.ts

@@ -31,6 +31,7 @@ interface DocumentInput {
   readonly log?: string
   readonly session?: { readonly id: string; readonly resume: boolean }
   readonly validate?: string
+  readonly fresh?: string | null
   readonly changes?: readonly StatusChange[]
   readonly next?: NextMatch | null
   readonly cost?: number
@@ -47,6 +48,7 @@ const demandInput = (
   kind: input.kind,
   ...(input.session !== undefined ? { session: input.session } : {}),
   ...(input.validate !== undefined ? { validate: input.validate } : {}),
+  ...(input.fresh !== undefined ? { fresh: input.fresh } : {}),
 })
 
 /** `statusOf`'s own input, isolated for the same reason as `demandInput` above. */
@@ -84,6 +86,7 @@ describe("beatDocument / renderBeatJson", () => {
       content: "fix it",
       idle: false,
       initial: false,
+      fresh: null,
       log: ".git/gtd-loop.log",
       state: "build.fixing",
       actor: "agent",
@@ -138,6 +141,16 @@ describe("beatDocument / renderBeatJson", () => {
     expect(parsed.validate).toBe("gtd check qa 'TODO.md'")
   })
 
+  it("carries fresh at kind prompt and null at every other kind", () => {
+    const parsed = JSON.parse(renderJsonLine({ kind: "prompt", fresh: "p\n\nc" })) as {
+      fresh: unknown
+    }
+    expect(parsed.fresh).toBe("p\n\nc")
+    for (const kind of BEAT_KINDS.filter((k) => k !== "prompt")) {
+      expect((JSON.parse(renderJsonLine({ kind })) as { fresh: unknown }).fresh).toBeNull()
+    }
+  })
+
   it("omits session/validate at kind prompt when the caller supplied none, never emitting null", () => {
     const line = renderJsonLine({ kind: "prompt" })
     const parsed = JSON.parse(line) as Record<string, unknown>
@@ -256,6 +269,7 @@ describe("beatDocument / renderBeatJson", () => {
       "model",
       "system",
       "validate",
+      "fresh",
       "log",
       "state",
       "actor",
@@ -395,6 +409,7 @@ describe("golden bytes", () => {
         content: "fix it",
         idle: false,
         initial: false,
+        fresh: null,
         log: ".git/gtd-loop.log",
         state: "build.fixing",
         actor: "agent",

package/src/wire/BeatDocument.ts

@@ -33,6 +33,7 @@ const dispatchFieldsOf = (
 ): {
   readonly session: DemandSession | undefined
   readonly validate: string | undefined
+  readonly fresh: string | null
   readonly skills: readonly string[] | undefined
   readonly access: StepAccess | undefined
   readonly pin: PinMark | undefined
@@ -40,6 +41,7 @@ const dispatchFieldsOf = (
   const none = {
     session: undefined,
     validate: undefined,
+    fresh: null,
     skills: undefined,
     access: undefined,
     pin: undefined,
@@ -50,6 +52,7 @@ const dispatchFieldsOf = (
         ...none,
         session: demand.session,
         validate: demand.validate,
+        fresh: demand.fresh,
         skills: demand.skills,
         access: demand.access,
       }
@@ -75,6 +78,8 @@ export interface BeatDocument {
   readonly model: string | undefined
   readonly system: string | undefined
   readonly validate: string | undefined
+  /** A validator retry with `session.resume`: the original prompt plus the correction, for a driver that starts a new session. `null` otherwise. */
+  readonly fresh: string | null
   /** On a pin or unpin beat only: what its script does to `.gtd/process.gtdpin`. */
   readonly pin: PinMark | undefined
   readonly log: string
@@ -96,13 +101,13 @@ export interface BeatDocument {
 }
 
 /**
- * Flatten a `Demand` plus its `BeatStatus` into the single 26-key document
+ * Flatten a `Demand` plus its `BeatStatus` into the single 27-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, pin } = dispatchFieldsOf(demand)
+  const { session, validate, fresh, skills, access, pin } = dispatchFieldsOf(demand)
   const hasCost = status.cost > 0
   return {
     schema: WIRE_SCHEMA,
@@ -114,6 +119,7 @@ export const beatDocument = (demand: Demand, status: BeatStatus): BeatDocument =
     model: status.model,
     system: status.system,
     validate,
+    fresh,
     pin,
     log: status.log,
     state: status.state,

package/src/wire/Demand.ts

@@ -54,14 +54,24 @@ export const beatKindOf = (input: {
  * `stalled at "<state>"` stays a stable substring (see
  * `tests/integration/features/driver-doc.feature`).
  */
-export const stallDiagnosis = (state: StateName, actor: Actor): string =>
-  `stalled at "${state}": the last gtd(${actor}): ${state} turn landed an empty ` +
-  `attempt, the tree is clean, and another dispatch would repeat it.\n\n` +
-  `Two ways out:\n` +
-  `  - sharpen the step's prompt so the turn has something concrete to author\n` +
-  `  - pass allowEmpty: true to the step, so an empty turn completes it and the\n` +
-  `    flow decides what follows — finishing, or an escalation step after N\n` +
-  `    empty turns\n`
+export const stallDiagnosis = (
+  state: StateName,
+  actor: Actor,
+  failure?: string,
+  blocked?: string,
+): string =>
+  blocked !== undefined
+    ? `stalled at "${state}": landing this ship step is refused.\n\n${blocked}\n`
+    : failure !== undefined
+      ? `stalled at "${state}": the script exited non-zero and its failure is recorded in the tree. ` +
+        `Change the tree to run the script again; the step advances only on a zero exit.\n\n${failure}`
+      : `stalled at "${state}": the last gtd(${actor}): ${state} turn landed an empty ` +
+        `attempt, the tree is clean, and another dispatch would repeat it.\n\n` +
+        `Two ways out:\n` +
+        `  - sharpen the step's prompt so the turn has something concrete to author\n` +
+        `  - pass allowEmpty: true to the step, so an empty turn completes it and the\n` +
+        `    flow decides what follows — finishing, or an escalation step after N\n` +
+        `    empty turns\n`
 
 /** One dispatch session — `resume`'s own meaning lives with `src/wire/Sessions.ts`'s `resolveSession`, which produces it. */
 export interface DemandSession {
@@ -86,6 +96,7 @@ export type Demand =
       readonly content: string
       readonly session: DemandSession | undefined
       readonly validate: string | undefined
+      readonly fresh: string | null
       readonly skills: readonly string[] | undefined
       readonly access: StepAccess
     }
@@ -100,19 +111,22 @@ export type Demand =
 export const demandOf = (input: {
   readonly rendered: Pick<
     RenderedDemandSource,
-    "actor" | "content" | "state" | "skills" | "access" | "pin"
+    "actor" | "content" | "state" | "skills" | "access" | "pin" | "failure" | "blocked"
   >
   readonly kind: BeatKind
   readonly session?: DemandSession
   readonly validate?: string
+  readonly fresh?: string | null
 }): Demand => {
-  const { rendered, kind, session, validate } = input
+  const { rendered, kind, session, validate, fresh = null } = input
   const content =
-    kind === "stalled" ? stallDiagnosis(rendered.state, rendered.actor) : rendered.content
+    kind === "stalled"
+      ? stallDiagnosis(rendered.state, rendered.actor, rendered.failure, rendered.blocked)
+      : rendered.content
   const skills =
     rendered.skills !== undefined && rendered.skills.length > 0 ? rendered.skills : undefined
   const access = rendered.access ?? { read: null, write: null }
-  if (kind === "prompt") return { kind, content, session, validate, skills, access }
+  if (kind === "prompt") return { kind, content, session, validate, fresh, skills, access }
   if (kind === "script" && rendered.pin !== undefined) return { kind, content, pin: rendered.pin }
   return { kind, content }
 }

package/src/wire/constants.ts

@@ -23,3 +23,6 @@ export const ACCESS_REFUSAL =
 
 /** 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"
+
+/** Where a `run(…, { onFail: "rest" })` body's failure is recorded in the tree: the exit status and the output. */
+export const RUN_FAILED_PATH = ".gtd/run-failed.txt"

package/src/wire/golden/1/beat-capture.json

@@ -6,6 +6,7 @@
   "initial": false,
   "model": "opus",
   "system": "You are a careful senior engineer.",
+  "fresh": null,
   "log": ".git/gtd-loop.log",
   "state": "build.fixing",
   "actor": "agent",

package/src/wire/golden/1/beat-message.json

@@ -6,6 +6,7 @@
   "initial": false,
   "model": "opus",
   "system": "You are a careful senior engineer.",
+  "fresh": null,
   "log": ".git/gtd-loop.log",
   "state": "build.fixing",
   "actor": "agent",

package/src/wire/golden/1/beat-prompt.json

@@ -11,6 +11,7 @@
   "model": "opus",
   "system": "You are a careful senior engineer.",
   "validate": "gtd check qa 'TODO.md'",
+  "fresh": null,
   "log": ".git/gtd-loop.log",
   "state": "build.fixing",
   "actor": "agent",

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

@@ -6,6 +6,7 @@
   "initial": false,
   "model": "opus",
   "system": "You are a careful senior engineer.",
+  "fresh": null,
   "log": ".git/gtd-loop.log",
   "state": "build.fixing",
   "actor": "agent",

package/src/wire/golden/1/beat-stalled.json

@@ -6,6 +6,7 @@
   "initial": false,
   "model": "opus",
   "system": "You are a careful senior engineer.",
+  "fresh": null,
   "log": ".git/gtd-loop.log",
   "state": "build.fixing",
   "actor": "agent",

package/src/wire/types.ts

@@ -55,4 +55,8 @@ export interface RenderedDemandSource {
   readonly skills?: readonly string[]
   readonly access?: StepAccess
   readonly pin?: PinMark
+  /** The recorded output of a failed `onFail: "rest"` run, shown at the stalled beat. */
+  readonly failure?: string
+  /** Why landing a ship step is refused, shown at the stalled beat. */
+  readonly blocked?: string
 }

package/src/workflow/Workflow.ts

@@ -42,6 +42,9 @@ export interface StepDef {
   readonly requireRevert?: boolean
   readonly allowEmpty?: boolean
   readonly keep?: boolean
+  /** A validator retry: the step's original prompt, `content` being the correction. */
+  readonly original?: string
+  readonly onFail?: "rest"
   readonly acceptClean?: boolean
   readonly approve?: boolean
   readonly skills?: readonly string[]

package/src/workflow/compile.ts

@@ -8,6 +8,7 @@ export interface CompiledConfig {
   /** The built-in modes (qa/review, with gtd's own validators) merged with `config.modes`, per half. */
   readonly modes: Record<string, ModeDef>
   readonly ui?: UiSettings
+  readonly historyRemote?: string
   readonly skills: Readonly<Record<string, readonly string[]>>
   readonly access: GtdConfig["access"] & {}
   readonly diagnostics: readonly Diagnostic[]
@@ -48,6 +49,7 @@ export const compileConfig = (value: unknown, origin: string): CompiledConfig =>
   return {
     modes,
     ...(config.ui !== undefined ? { ui: config.ui } : {}),
+    ...(config.historyRemote !== undefined ? { historyRemote: config.historyRemote } : {}),
     // Null prototype: a `__proto__` key must stay an ordinary (reportable) entry.
     skills: Object.assign(Object.create(null), config.skills),
     access: Object.assign(Object.create(null), config.access),

package/src/workflow/load.ts

@@ -40,6 +40,7 @@ export interface ConfigOperations {
   readonly doors: ReadonlyMap<string, Door>
   /** `config.ui` (absent when unconfigured) — `gtd ui` and its CLI flags read it. */
   readonly ui?: flows.UiSettings
+  readonly historyRemote?: string
   /** Non-fatal findings, formatted through `formatDiagnostic` like an error. */
   readonly warnings: readonly Diagnostic[]
   /** The content hash of every file `gtd.config.ts`'s evaluation touched — itself plus any relative import — by path relative to the root. */
@@ -197,6 +198,7 @@ export const load: Effect.Effect<
       return entry === undefined ? undefined : resolve(name, entry)
     },
     ...(compiled.ui !== undefined ? { ui: compiled.ui } : {}),
+    ...(compiled.historyRemote !== undefined ? { historyRemote: compiled.historyRemote } : {}),
     warnings: diagnostics.filter((d) => d.severity === "warning"),
     fingerprint:
       pinned?.fingerprint ??

package/src/workflow-kit/index.test.ts

@@ -5,6 +5,7 @@ describe("@pmelab/gtd/workflow-kit", () => {
   it("publishes its helpers by name", () => {
     expect(Object.keys(kit).sort()).toEqual(
       [
+        "assertionErrors",
         "assertionLines",
         "escalation",
         "fixFindings",

package/src/workflow-kit/index.ts

@@ -23,6 +23,7 @@ export {
 } from "./quality.js"
 export {
   assertionLines,
+  assertionErrors,
   removedAssertions,
   type Assertion,
   type RemovedAssertions,

package/src/workflow-kit/scenarios.ts

@@ -68,3 +68,11 @@ export const removedAssertions = (changes: readonly Change[]): readonly RemovedA
       return { path: c.path, lines }
     })
     .filter((r) => r.lines.length > 0)
+
+/** Validator form of `removedAssertions`: lists each lost line by path and scenario, or `undefined` when none. */
+export const assertionErrors = (changes: readonly Change[]): string | undefined => {
+  const lost = removedAssertions(changes)
+  if (lost.length === 0) return undefined
+  const lines = lost.flatMap((r) => r.lines.map((a) => `  - ${r.path}: ${a.scenario}: ${a.line}`))
+  return `Restore the assertions these .feature files lost:\n${lines.join("\n")}`
+}