@pmelab/gtd 52.1.0 → 54.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "52.1.0",
+  "version": "54.0.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {

package/src/cli/Cli.test.ts

@@ -112,7 +112,6 @@ describe("parseArgv — scope", () => {
       ["judge", "--json"],
       ["judge", "answer", "--json"],
       ["doors", "--json"],
-      ["slices", "--json"],
     ]) {
       const ok = parseArgv(["node", "gtd.js", ...args])
       expect(ok.kind).toBe("command")
@@ -929,79 +928,6 @@ describe("parseArgv — doors", () => {
   })
 })
 
-describe("parseArgv — slices", () => {
-  const parse = (...args: string[]): CliPlan => parseArgv(["node", "gtd.js", ...args])
-
-  it("`gtd slices` parses with every --json shape", () => {
-    expect(parse("slices")).toMatchObject({
-      kind: "command",
-      command: { kind: "slices" },
-      json: { kind: "off" },
-    })
-    expect(parse("slices", "--json")).toMatchObject({ json: { kind: "document" } })
-    expect(parse("slices", "--json=slices.0.name")).toMatchObject({
-      json: { kind: "select", path: "slices.0.name" },
-    })
-  })
-
-  it("`gtd slices` takes no argument", () => {
-    const plan = parse("slices", "extra")
-    expect(plan.kind).toBe("usage")
-    if (plan.kind === "usage") expect(plan.message).toContain("too many arguments")
-  })
-
-  it("help lists the command, and --json names it", () => {
-    const help = renderHelp()
-    expect(help).toMatch(/^ {2}slices\b/m)
-    expect(help).toContain("gtd slices")
-  })
-
-  it("--json's scope error names gtd slices", () => {
-    const plan = parse("lsp", "--json")
-    expect(plan.kind).toBe("usage")
-    if (plan.kind === "usage") expect(plan.message).toContain("`gtd slices`")
-  })
-})
-
-describe("parseArgv — summary --slice", () => {
-  const parse = (...args: string[]): CliPlan => parseArgv(["node", "gtd.js", ...args])
-  const usage = (plan: CliPlan): string => (plan.kind === "usage" ? plan.message : "")
-
-  it("`--slice build` and `--slice=build` parse to the slice name", () => {
-    for (const plan of [parse("summary", "--slice", "build"), parse("summary", "--slice=build")]) {
-      expect(plan).toMatchObject({ kind: "command", command: { kind: "summary", slice: "build" } })
-    }
-  })
-
-  it("plain `summary` carries no slice key", () => {
-    const plan = parse("summary")
-    expect(plan.kind === "command" && plan.command).toEqual({ kind: "summary" })
-  })
-
-  it("bare `--slice` is a usage error naming the value form", () => {
-    const plan = parse("summary", "--slice")
-    expect(plan.kind).toBe("usage")
-    expect(usage(plan)).toContain("--slice")
-    expect(usage(plan)).toContain("value")
-  })
-
-  it("`--slice` twice is a usage error", () => {
-    expect(parse("summary", "--slice", "a", "--slice", "b").kind).toBe("usage")
-  })
-
-  it("`--slice` on another command fails the scope check naming gtd summary", () => {
-    for (const command of ["slices", "next"]) {
-      const plan = parse(command, "--slice", "build")
-      expect(plan.kind).toBe("usage")
-      expect(usage(plan)).toContain("`gtd summary`")
-    }
-  })
-
-  it("help lists the flag", () => {
-    expect(renderHelp()).toContain("--slice=<name>")
-  })
-})
-
 describe("parseArgv — gtd history", () => {
   const parse = (...args: string[]) => parseArgv(["node", "gtd.js", ...args])
   const usage = (plan: CliPlan): string => (plan.kind === "usage" ? plan.message : "")
@@ -1142,15 +1068,7 @@ describe("parseArgv — gtd strays", () => {
 
 describe("standaloneKinds / needsOf", () => {
   it("pins the standalone kinds", () => {
-    expect(standaloneKinds()).toEqual([
-      "lsp",
-      "check",
-      "uncheck",
-      "install",
-      "contextHook",
-      "judgeRun",
-      "strays",
-    ])
+    expect(standaloneKinds()).toEqual(["lsp", "check", "uncheck", "install", "judgeRun", "strays"])
   })
 
   it("needsOf matches none/fs for the standalone kinds and state for everything else", () => {
@@ -1158,7 +1076,6 @@ describe("standaloneKinds / needsOf", () => {
     expect(needsOf("check")).toBe("fs")
     expect(needsOf("uncheck")).toBe("fs")
     expect(needsOf("install")).toBe("none")
-    expect(needsOf("contextHook")).toBe("none")
     expect(needsOf("judgeRun")).toBe("none")
     expect(needsOf("strays")).toBe("none")
     for (const kind of [
@@ -1173,7 +1090,6 @@ describe("standaloneKinds / needsOf", () => {
       "judgeAnswer",
       "door",
       "doors",
-      "slices",
       "historyList",
       "historyShow",
       "historyMetrics",
@@ -1251,7 +1167,6 @@ describe("renderHelp", () => {
       ),
     )
     expect(commands).toContain("judge answer")
-    expect(commands).toContain("context-hook")
     const listed = (file: string, list: RegExp): Set<string> => {
       const doc = readFileSync(resolve(import.meta.dirname, file), "utf8")
       const match = doc.match(list)

package/src/cli/Cli.ts

@@ -36,7 +36,7 @@ import {
 } from "./Program.js"
 import type { ToolCommands } from "./ToolCommands.js"
 import { THRESHOLDS } from "./Judges.js"
-import { EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR, parseContextWindow } from "../wire/index.js"
+import { EXIT_RUNTIME_ERROR, EXIT_USAGE_ERROR } from "../wire/index.js"
 
 export type { Command, CommandRequirements } from "./Program.js"
 export { needsOf, standaloneKinds } from "./Program.js"
@@ -91,20 +91,12 @@ const nonNegativeNumber = (raw: string, flag: string): Either.Either<number, str
   return Either.right(n)
 }
 
-const share = (raw: string, flag: string): Either.Either<number, string> => {
-  const n = Number(raw)
-  return raw.trim() !== "" && n > 0 && n <= 1
-    ? Either.right(n)
-    : Either.left(`gtd: ${flag} must be a share of the context window in (0, 1] — got "${raw}"`)
-}
-
 const JSON_KINDS: ReadonlySet<Command["kind"] | undefined> = new Set<Command["kind"]>([
   "next",
   "land",
   "judge",
   "judgeAnswer",
   "doors",
-  "slices",
   "historyList",
   "historyShow",
   "historyMetrics",
@@ -120,11 +112,11 @@ const FLAGS: readonly FlagRow[] = [
     scope: (kind) => JSON_KINDS.has(kind),
     decode: ([raw]) => Either.right(raw ?? ""),
     scopeError:
-      "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd slices`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd history judges`/`gtd strays` — " +
+      "gtd: --json is only valid for `gtd next`/`gtd land`/`gtd judge`/`gtd judge answer`/`gtd doors`/`gtd history list`/`gtd history show`/`gtd history metrics`/`gtd history judges`/`gtd strays` — " +
       "every other command prints plain text; see `gtd install` for the driver protocol briefing",
     valueHint: "<path>",
     help: [
-      "(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd slices/gtd history",
+      "(gtd next/gtd land/gtd judge/gtd judge answer/gtd doors/gtd history",
       "list/gtd history show/gtd history metrics/gtd history judges/gtd strays only) output structured JSON. Bare --json prints the whole document;",
       "--json=<path> (a dotted key path into that document, e.g.",
       "kind, content, session.id) prints just that value: a",
@@ -258,56 +250,6 @@ const FLAGS: readonly FlagRow[] = [
       "GTD_JUDGE_MODEL, then judge.json, then sonnet",
     ],
   },
-  {
-    name: "--soft",
-    arity: 1,
-    repeatable: false,
-    scope: (kind) => kind === "contextHook",
-    decode: ([raw]) => share(raw ?? "", "--soft"),
-    scopeError: "gtd: --soft is only valid for `gtd context-hook`",
-    valueHint: "<share>",
-    help: ["(gtd context-hook only) the soft limit; default 0.6"],
-  },
-  {
-    name: "--hard",
-    arity: 1,
-    repeatable: false,
-    scope: (kind) => kind === "contextHook",
-    decode: ([raw]) => share(raw ?? "", "--hard"),
-    scopeError: "gtd: --hard is only valid for `gtd context-hook`",
-    valueHint: "<share>",
-    help: ["(gtd context-hook only) the hard limit; default 0.7"],
-  },
-  {
-    name: "--window",
-    arity: 1,
-    repeatable: false,
-    scope: (kind) => kind === "contextHook",
-    decode: ([raw]) => {
-      const window = parseContextWindow(raw)
-      return window !== undefined
-        ? Either.right(window)
-        : Either.left(`gtd: --window must be a positive integer — got "${raw ?? ""}"`)
-    },
-    scopeError: "gtd: --window is only valid for `gtd context-hook`",
-    valueHint: "<tokens>",
-    help: ["(gtd context-hook only) the model's context window in", "tokens; default 200000"],
-  },
-  {
-    name: "--slice",
-    arity: 1,
-    repeatable: false,
-    scope: (kind) => kind === "summary",
-    decode: ([raw]) => Either.right(raw!),
-    scopeError: "gtd: --slice is only valid for `gtd summary`",
-    valueHint: "<name>",
-    help: [
-      "(gtd summary only) the closing-message prompt for one",
-      "slice, named as `gtd slices` lists it: its own range, human",
-      "commits and cost. An unknown name is refused (exit 1) with",
-      "every valid slice listed",
-    ],
-  },
   {
     name: "--workflow",
     arity: 1,
@@ -642,22 +584,6 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "else it writes nothing.",
     ],
   },
-  {
-    token: "context-hook",
-    kind: "contextHook",
-    arity: "none",
-    details: [
-      "A Claude Code PostToolUse and PreCompact hook that stops an",
-      "agent turn at a share of its context window. Reads the",
-      "hook's input on stdin and the context the transcript's",
-      "latest assistant message used. Past --soft it blocks with a",
-      "request to end the turn with a handoff note; past --hard,",
-      "or at PreCompact, it stops the turn with a stopReason",
-      'starting "gtd: context limit". Prints nothing otherwise,',
-      "and for a subagent's tool call. Always exits 0 on valid",
-      "input; see docs/driver.md",
-    ],
-  },
   {
     token: "summary",
     kind: "summary",
@@ -671,15 +597,10 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "no state transition, no file, no session identity — the",
       "driver pipes the output to a cold agent and does what it",
       "wants with the result (a squash, an amend, a PR body).",
-      "--slice <name> prints it for one slice instead: its own",
-      "range, human commits and cost (see `gtd slices`); it also",
-      "refuses an unknown slice name, and a HEAD-closing process",
-      "whose config files differ from the working tree or whose",
-      "replay diverged; an open last slice is provisional. Refuses",
-      "(exit 1) when the workflow declares no summary: template,",
-      "or when the resolved run has no commits to name — plain",
-      "gtd summary is runnable any time before the next thing",
-      "lands on the branch",
+      "Refuses (exit 1) when the workflow declares no summary:",
+      "template, or when the resolved run has no commits to name —",
+      "it is runnable any time before the next thing lands on the",
+      "branch",
     ],
   },
   {
@@ -722,25 +643,6 @@ const COMMAND_ROWS: readonly CommandRow[] = [
       "value off it. Writes nothing",
     ],
   },
-  {
-    token: "slices",
-    kind: "slices",
-    arity: "none",
-    details: [
-      "List the slices of the process HEAD closes or sits inside,",
-      "first slice first: one `name base..tip` line each (full",
-      "hashes; plain output carries no promise). --json prints",
-      "{ schema: 1, slices: [{ name, base, tip, closed }] };",
-      "--json=<path> reads one value off it. Writes nothing: no",
-      "git, no state transition, no session identity. When HEAD",
-      "closes a process, every slice is listed as closed; a gtd",
-      "version mismatch only warns on stderr. Refuses (exit 1)",
-      "when HEAD neither closes nor sits inside a process, or when",
-      "today's config disagrees with history about the process:",
-      "HEAD closes it and its config files differ from the working",
-      "tree, or the replay diverged",
-    ],
-  },
   {
     token: "judge",
     kind: "judge",
@@ -836,11 +738,11 @@ const COMMAND_ROWS: readonly CommandRow[] = [
     kind: "historyMetrics",
     arity: { name: "ref", many: true },
     details: [
-      "Report how the kept processes went: slices whose naive pass",
-      "landed or was rebuilt (the refactor-first rate), continuations",
-      "per phase, Gtd-Cost by model and phase with the double work of",
-      "a rebuild, quality-lap findings per lens, and red checks that",
-      "passed on their re-check — per process and in total. Each <ref>",
+      "Report how the kept processes went: builds whose naive pass",
+      "landed or was rebuilt (the refactor-first rate), Gtd-Cost by",
+      "model and phase with the double work of a rebuild, quality-lap",
+      "findings per lens, and red checks that passed on their",
+      "re-check — per process and in total. Each <ref>",
       "is read as by history show, but a branch name means every",
       "process kept from it; none means every ref.",
       "Reads commit subjects and trailers, never replays, so a",
@@ -1282,10 +1184,6 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     readonly "--dev"?: boolean
     readonly "--provider"?: "fixed" | "jev" | "llm"
     readonly "--answers"?: string
-    readonly "--slice"?: string
-    readonly "--soft"?: number
-    readonly "--hard"?: number
-    readonly "--window"?: number
     readonly "--jsonl"?: boolean
   }
 
@@ -1390,27 +1288,10 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     }
   }
 
-  if (kind === "contextHook") {
-    return {
-      kind: "command",
-      command: {
-        kind: "contextHook",
-        ...(bag["--soft"] !== undefined ? { soft: bag["--soft"] } : {}),
-        ...(bag["--hard"] !== undefined ? { hard: bag["--hard"] } : {}),
-        ...(bag["--window"] !== undefined ? { window: bag["--window"] } : {}),
-      },
-      json,
-      verbose,
-    }
-  }
-
   if (kind === "summary") {
     return {
       kind: "command",
-      command: {
-        kind: "summary",
-        ...(bag["--slice"] !== undefined ? { slice: bag["--slice"] } : {}),
-      },
+      command: { kind: "summary" },
       json,
       verbose,
     }
@@ -1515,7 +1396,6 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
       | "validate"
       | "install"
       | "doors"
-      | "slices"
       | "base"
       | "judge"
       | "judgeAnswer"

package/src/cli/Metrics.test.ts

@@ -10,50 +10,50 @@ const turn = (subject: string, opts: { cost?: string; findings?: number } = {}):
 })
 
 describe("processMetrics", () => {
-  it("counts a naive pass applied as it is as a landed slice", () => {
+  it("counts a naive pass applied as it is as a landed build", () => {
     const m = processMetrics([
       turn("gtd(human): idle → seam.naive"),
       turn("gtd(agent): seam.naive → seam.check", { cost: "0.4 coder" }),
       turn("gtd(check): seam.check → implement.applying"),
       turn("gtd(check): implement.applying → idle"),
     ])
-    expect(m.slices).toEqual({ decided: 1, landed: 1, rebuilt: 0, refactored: 0 })
+    expect(m.builds).toEqual({ decided: 1, landed: 1, rebuilt: 0, refactored: 0 })
     expect(m.refactorFirstRate).toBe(0)
     expect(m.cost.byPhase).toEqual({ naive: 0.4, refactor: 0, implement: 0, other: 0 })
     expect(m.cost.doubleWork).toEqual({ naive: 0, rebuild: 0, total: 0 })
   })
 
-  it("charges a rebuilt slice's naive pass and rebuild as double work, refactor apart", () => {
+  it("charges a rebuilt build's naive pass and rebuild as double work, refactor apart", () => {
     const m = processMetrics([
       turn("gtd(human): idle → seam.naive"),
-      turn("gtd(agent): seam.naive → seam.continue.naive", { cost: "0.4 coder" }),
-      turn("gtd(agent): seam.continue.naive → seam.judge", { cost: "0.2 coder" }),
+      turn("gtd(agent): seam.naive → seam.check", { cost: "0.4 coder" }),
+      turn("gtd(check): seam.check → seam.naive"),
+      turn("gtd(agent): seam.naive → seam.judge", { cost: "0.2 coder" }),
       turn("gtd(judge): seam.judge → seam.note", { cost: "0.01 judge" }),
       turn("gtd(agent): seam.note → refactor.deriving", { cost: "0.05 coder" }),
       turn("gtd(check): refactor.deriving → refactor.building"),
       turn("gtd(agent): refactor.building → refactor.closing", { cost: "0.3 coder" }),
       turn("gtd(check): refactor.closing → implement.building"),
-      turn("gtd(agent): implement.building → implement.continue.building", { cost: "0.5 coder" }),
-      turn("gtd(agent): implement.continue.building → idle", { cost: "0.25 coder" }),
+      turn("gtd(agent): implement.building → implement.health.check", { cost: "0.5 coder" }),
+      turn("gtd(agent): implement.fix → idle", { cost: "0.25 coder" }),
     ])
-    expect(m.slices).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 1 })
+    expect(m.builds).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 1 })
     expect(m.refactorFirstRate).toBe(1)
-    expect(m.continuations).toEqual({ "seam.naive": 1, "implement.building": 1 })
     expect(m.cost.total).toBe(1.71)
     expect(m.cost.byModel).toEqual({ coder: 1.7, judge: 0.01 })
     expect(m.cost.byPhase).toEqual({ naive: 0.6, refactor: 0.35, implement: 0.75, other: 0.01 })
     expect(m.cost.doubleWork).toEqual({ naive: 0.6, rebuild: 0.75, total: 1.35 })
   })
 
-  it("rebuilds without a refactor when the slice leaves the seam for a build turn", () => {
+  it("rebuilds without a refactor when the build leaves the seam for a build turn", () => {
     const m = processMetrics([
       turn("gtd(judge): seam.judge → implement.building"),
       turn("gtd(agent): implement.building → idle"),
     ])
-    expect(m.slices).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 0 })
+    expect(m.builds).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 0 })
   })
 
-  it("keeps each slice's decision apart", () => {
+  it("keeps each build's decision apart", () => {
     const m = processMetrics([
       turn("gtd(agent): seam.naive → seam.check", { cost: "1" }),
       turn("gtd(check): seam.check → implement.applying"),
@@ -61,20 +61,19 @@ describe("processMetrics", () => {
       turn("gtd(check): implement.closing → seam.naive"),
       turn("gtd(agent): seam.naive → seam.note", { cost: "2" }),
       turn("gtd(agent): seam.note → refactor.deriving"),
-      turn("gtd(agent): refactor.continue.building → refactor.closing", { cost: "1" }),
+      turn("gtd(agent): refactor.building → refactor.closing", { cost: "1" }),
       turn("gtd(check): refactor.closing → implement.building"),
       turn("gtd(agent): implement.building → idle", { cost: "3" }),
     ])
-    expect(m.slices).toEqual({ decided: 2, landed: 1, rebuilt: 1, refactored: 1 })
+    expect(m.builds).toEqual({ decided: 2, landed: 1, rebuilt: 1, refactored: 1 })
     expect(m.refactorFirstRate).toBe(0.5)
-    expect(m.continuations).toEqual({ "refactor.building": 1 })
     expect(m.cost.byModel).toEqual({ unspecified: 8 })
     expect(m.cost.doubleWork).toEqual({ naive: 2, rebuild: 3, total: 5 })
   })
 
-  it("counts a naive retry in a fresh conversation as naive cost", () => {
+  it("counts a naive pass under an older history's scope as naive cost", () => {
     const m = processMetrics([
-      turn("gtd(agent): seam.continue.naive → seam.judge", { cost: "1" }),
+      turn("gtd(agent): seam.naive → seam.judge", { cost: "1" }),
       turn("gtd(judge): seam.judge → seam.fresh.naive"),
       turn("gtd(agent): seam.fresh.naive → seam.judge", { cost: "2" }),
       turn("gtd(judge): seam.judge → implement.building"),
@@ -83,14 +82,14 @@ describe("processMetrics", () => {
     expect(m.cost.doubleWork.naive).toBe(3)
   })
 
-  it("turns a landed slice whose naive pass fails to apply into a rebuild", () => {
+  it("turns a landed build whose naive pass fails to apply into a rebuild", () => {
     const m = processMetrics([
       turn("gtd(agent): seam.naive → seam.check", { cost: "1" }),
       turn("gtd(check): seam.check → implement.applying"),
       turn("gtd(check): implement.applying → implement.building"),
       turn("gtd(agent): implement.building → implement.health.check", { cost: "2" }),
     ])
-    expect(m.slices).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 0 })
+    expect(m.builds).toEqual({ decided: 1, landed: 0, rebuilt: 1, refactored: 0 })
     expect(m.cost.doubleWork).toEqual({ naive: 1, rebuild: 2, total: 3 })
   })
 
@@ -107,7 +106,7 @@ describe("processMetrics", () => {
     })
   })
 
-  it("ends a rebuild's double work at the slice's closing", () => {
+  it("ends a rebuild's double work at the build's closing", () => {
     const m = processMetrics([
       turn("gtd(judge): seam.judge → implement.building"),
       turn("gtd(agent): implement.building → implement.closing", { cost: "1" }),
@@ -134,14 +133,6 @@ describe("processMetrics", () => {
     expect(processMetrics([turn("gtd(human): idle → building")]).refactorFirstRate).toBeNull()
   })
 
-  it("counts continuations only for agent turns, the bare form included", () => {
-    const m = processMetrics([
-      turn("gtd(agent): seam.continue.naive"),
-      turn("gtd(human): seam.continue.naive → seam.oversized"),
-    ])
-    expect(m.continuations).toEqual({ "seam.naive": 1 })
-  })
-
   it("sums findings per quality lens and skips commits gtd did not write", () => {
     const m = processMetrics([
       turn(
@@ -201,16 +192,15 @@ describe("totalMetrics", () => {
       turn("gtd(check): seam.check → implement.applying"),
     ])
     const b = processMetrics([
-      turn("gtd(agent): seam.continue.naive → seam.note", { cost: "2 b" }),
+      turn("gtd(agent): seam.naive → seam.note", { cost: "2 b" }),
       turn("gtd(agent): seam.note → refactor.deriving"),
       turn("gtd(agent): seam.naive → seam.note"),
       turn("gtd(agent): seam.note → refactor.deriving"),
     ])
     const total = totalMetrics([a, b])
     expect(total.processes).toBe(2)
-    expect(total.slices).toEqual({ decided: 3, landed: 1, rebuilt: 2, refactored: 2 })
+    expect(total.builds).toEqual({ decided: 3, landed: 1, rebuilt: 2, refactored: 2 })
     expect(total.refactorFirstRate).toBe(0.667)
-    expect(total.continuations).toEqual({ "seam.naive": 1 })
     expect(total.cost.byModel).toEqual({ a: 1, b: 2 })
   })
 })