@pmelab/gtd 52.0.0 → 53.0.0

package/src/cli/Metrics.ts

@@ -18,7 +18,8 @@ export interface MetricCommit {
 }
 
 export interface Metrics {
-  readonly slices: {
+  /** Each naive pass's decision: landed as it is, or rebuilt (after a refactor or not). */
+  readonly builds: {
     readonly decided: number
     readonly landed: number
     readonly rebuilt: number
@@ -26,8 +27,6 @@ export interface Metrics {
   }
   /** `rebuilt / decided`, to three places; null without a decision. */
   readonly refactorFirstRate: number | null
-  /** Continuation turns per phase, keyed by the step without its `continue` segment. */
-  readonly continuations: Readonly<Record<string, number>>
   readonly cost: {
     readonly total: number
     readonly byModel: Readonly<Record<string, number>>
@@ -37,7 +36,7 @@ export interface Metrics {
       readonly implement: number
       readonly other: number
     }
-    /** A rebuilt slice's naive pass and the implement turns that rebuilt it. */
+    /** A rebuilt build's naive pass and the implement turns that rebuilt it. */
     readonly doubleWork: {
       readonly naive: number
       readonly rebuild: number
@@ -54,11 +53,9 @@ type Phase = keyof Metrics["cost"]["byPhase"]
 // Keyed by the lap's path without `.reviewing`, so the refactor lap's lenses stay apart from the feature's.
 const LENS = /^((?:.*\.)?quality\.[^.]+)\.reviewing$/
 
-const CONTINUE = /(^|\.)continue\./
-
 const inSeam = (step: string): boolean => step.startsWith("seam.")
 
-// A naive retry after a continuation runs under `seam.fresh.naive`: any seam step named `naive` is the pass.
+// Any seam step named `naive` is the pass, whatever scope an older history ran it under.
 const phaseOf = (step: string): Phase => {
   const scope = step.split(".")[0]
   if (inSeam(step) && step.endsWith(".naive")) return "naive"
@@ -83,8 +80,7 @@ const roundAll = (record: Record<string, number>): Record<string, number> =>
   Object.fromEntries(Object.entries(record).map(([k, v]) => [k, round(v)]))
 
 interface Tally {
-  readonly slices: { decided: number; landed: number; rebuilt: number; refactored: number }
-  readonly continuations: Record<string, number>
+  readonly builds: { decided: number; landed: number; rebuilt: number; refactored: number }
   readonly byModel: Record<string, number>
   readonly byPhase: Record<Phase, number>
   readonly doubleWork: { naive: number; rebuild: number }
@@ -93,8 +89,7 @@ interface Tally {
 }
 
 const emptyTally = (): Tally => ({
-  slices: { decided: 0, landed: 0, rebuilt: 0, refactored: 0 },
-  continuations: record(),
+  builds: { decided: 0, landed: 0, rebuilt: 0, refactored: 0 },
   byModel: record(),
   byPhase: { naive: 0, refactor: 0, implement: 0, other: 0 },
   doubleWork: { naive: 0, rebuild: 0 },
@@ -106,9 +101,8 @@ const sum = (record: Readonly<Record<string, number>>): number =>
   Object.values(record).reduce((a, b) => a + b, 0)
 
 const finish = (t: Tally): Metrics => ({
-  slices: t.slices,
-  refactorFirstRate: t.slices.decided === 0 ? null : round(t.slices.rebuilt / t.slices.decided, 3),
-  continuations: t.continuations,
+  builds: t.builds,
+  refactorFirstRate: t.builds.decided === 0 ? null : round(t.builds.rebuilt / t.builds.decided, 3),
   cost: {
     total: round(sum(t.byModel)),
     byModel: roundAll(t.byModel),
@@ -123,8 +117,8 @@ const finish = (t: Tally): Metrics => ({
   flaky: { total: sum(t.flaky), byStep: t.flaky },
 })
 
-/** The open slice: its naive cost so far, and whether its implement turns rebuild it. */
-interface Slice {
+/** The open build: its naive cost so far, and whether its implement turns rebuild it. */
+interface Build {
   naive: number
   rebuilding: boolean
   /** Landed, not yet applied, with its naive cost: an apply that fails turns it into a rebuild. */
@@ -133,7 +127,7 @@ interface Slice {
 
 const tallyCost = (
   t: Tally,
-  open: Slice,
+  open: Build,
   costs: ReturnType<typeof parseCommitMessage>["cost"],
   phase: Phase,
 ): void => {
@@ -145,50 +139,48 @@ const tallyCost = (
   }
 }
 
-/** A slice is decided where its turns leave the seam: for `implement.applying` the naive pass landed — unless it fails to apply and is built afresh — anywhere else it is rebuilt. */
-const tallyDecision = (t: Tally, open: Slice, at: string, to: string): void => {
-  // The slice's closing ends its rebuild: later implement turns (an amend after review) are new work.
+/** A build is decided where its turns leave the seam: for `implement.applying` the naive pass landed — unless it fails to apply and is built afresh — anywhere else it is rebuilt. */
+const tallyDecision = (t: Tally, open: Build, at: string, to: string): void => {
+  // The build's closing ends its rebuild: later implement turns (an amend after review) are new work.
   if (at === "implement.closing") open.rebuilding = false
   if (open.applying !== undefined && at === "implement.applying") {
     const naive = open.applying
     open.applying = undefined
     if (to !== "implement.building") return
-    t.slices.landed--
+    t.builds.landed--
     rebuild(t, open, naive)
     return
   }
   if (!inSeam(at) || inSeam(to)) return
-  t.slices.decided++
+  t.builds.decided++
   const naive = open.naive
   open.naive = 0
   if (to === "implement.applying") {
     open.applying = naive
     open.rebuilding = false
-    t.slices.landed++
+    t.builds.landed++
     return
   }
   rebuild(t, open, naive)
-  if (at === "seam.note") t.slices.refactored++
+  if (at === "seam.note") t.builds.refactored++
 }
 
-const rebuild = (t: Tally, open: Slice, naive: number): void => {
+const rebuild = (t: Tally, open: Build, naive: number): void => {
   open.rebuilding = true
-  t.slices.rebuilt++
+  t.builds.rebuilt++
   t.doubleWork.naive += naive
 }
 
 /** Oldest first; a commit gtd did not write is skipped. */
 export const processMetrics = (commits: readonly MetricCommit[]): Metrics => {
   const t = emptyTally()
-  const open: Slice = { naive: 0, rebuilding: false, applying: undefined }
+  const open: Build = { naive: 0, rebuilding: false, applying: undefined }
   for (const commit of commits) {
     const message = parseCommitMessage(commit.message)
     const subject = message.parsed
     if (subject === undefined) continue
     const at = subject.from ?? subject.to
     tallyCost(t, open, message.cost, phaseOf(at))
-    if (subject.actor === "agent" && CONTINUE.test(at))
-      add(t.continuations, at.replace(CONTINUE, "$1"), 1)
     const lens = LENS.exec(at)?.[1]
     if (lens !== undefined && commit.findings > 0) add(t.byLens, lens, commit.findings)
     if (message.marks.some((m) => m.name === "flaky")) add(t.flaky, at, 1)
@@ -200,9 +192,8 @@ export const processMetrics = (commits: readonly MetricCommit[]): Metrics => {
 export const totalMetrics = (all: readonly Metrics[]): Metrics & { readonly processes: number } => {
   const t = emptyTally()
   for (const m of all) {
-    for (const key of Object.keys(t.slices) as (keyof Tally["slices"])[])
-      t.slices[key] += m.slices[key]
-    for (const [k, v] of Object.entries(m.continuations)) add(t.continuations, k, v)
+    for (const key of Object.keys(t.builds) as (keyof Tally["builds"])[])
+      t.builds[key] += m.builds[key]
     for (const [k, v] of Object.entries(m.cost.byModel)) add(t.byModel, k, v)
     for (const key of Object.keys(t.byPhase) as Phase[]) t.byPhase[key] += m.cost.byPhase[key]
     t.doubleWork.naive += m.cost.doubleWork.naive
@@ -256,12 +247,10 @@ const listed = (record: Readonly<Record<string, number>>): string =>
     .join(", ")
 
 const line = (label: string, m: Metrics): string => {
-  const { slices, cost } = m
+  const { builds, cost } = m
   const percent = m.refactorFirstRate === null ? "-" : `${Math.round(m.refactorFirstRate * 100)}%`
-  const continued = sum(m.continuations)
   return [
-    `${label}: ${slices.decided} slices, ${slices.rebuilt} rebuilt (refactor-first ${percent}), ${slices.refactored} refactored`,
-    `${continued} continuations${continued > 0 ? ` (${listed(m.continuations)})` : ""}`,
+    `${label}: ${builds.decided} builds, ${builds.rebuilt} rebuilt (refactor-first ${percent}), ${builds.refactored} refactored`,
     `cost ${cost.total} (${listed(cost.byPhase)}; by model ${listed(cost.byModel) || "-"}), double work ${cost.doubleWork.total}`,
     `${m.findings.total} findings${m.findings.total > 0 ? ` (${listed(m.findings.byLens)})` : ""}`,
     `${m.flaky.total} flaky${m.flaky.total > 0 ? ` (${listed(m.flaky.byStep)})` : ""}`,

package/src/cli/Program.test.ts

@@ -1677,7 +1677,6 @@ describe("runCommand — refuses in a repository with no commits", () => {
     start: { kind: "start", actor: "human", workflow: "feature", vars: {}, label: "" },
     door: { kind: "door", name: "fix", args: [] },
     doors: { kind: "doors" },
-    slices: { kind: "slices" },
     abandon: { kind: "abandon" },
     restore: { kind: "restore" },
     next: { kind: "next" },
@@ -1685,7 +1684,6 @@ describe("runCommand — refuses in a repository with no commits", () => {
     check: { kind: "check", mode: "qa", file: ".gtd/TODO.md" },
     uncheck: { kind: "uncheck", file: ".gtd/REVIEW.md" },
     install: { kind: "install" },
-    contextHook: { kind: "contextHook" },
     summary: { kind: "summary" },
     base: { kind: "base" },
     judge: { kind: "judge" },
@@ -1706,14 +1704,13 @@ describe("runCommand — refuses in a repository with no commits", () => {
   const NO_COMMITS_MESSAGE =
     "gtd requires a repository with at least one commit — make an initial commit, then run gtd again"
 
-  it("derives exactly the nineteen non-standalone kinds — a canary for the table-driven cases below", () => {
+  it("derives exactly the eighteen non-standalone kinds — a canary for the table-driven cases below", () => {
     expect(stateKinds.sort()).toEqual(
       [
         "abandon",
         "base",
         "door",
         "doors",
-        "slices",
         "start",
         "land",
         "next",
@@ -1856,37 +1853,6 @@ export const summary = (c) => \`entry=\${c.entryCommit} tip=\${c.processTip} hum
   })
 })
 
-describe("gtd summary --slice", () => {
-  const SLICED = `import { agent, human, slice } from "@pmelab/gtd/flows"
-
-export default async () => {
-  await human("idle", { message: "hi" })
-  await slice("build", async () => {
-    await agent("working", "go")
-  })
-  await slice("verify", async () => {
-    await agent("polishing", "polish")
-  })
-}
-
-export const summary = (c) => \`\${c.slice ? c.slice.name + " " + c.slice.index + "/" + c.slice.count : "plain"} \${c.processBase}..\${c.processTip}\`
-`
-
-  it("a version warning goes to stderr, stdout still carries the prompt", async () => {
-    const repo = seed(SLICED)
-    await landTurn(repo, { "NOTE.md": "a note\n" })
-    await landTurn(repo, { "WORK.md": "done\n" })
-    repo.writeFile("POLISH.md", "ok\n")
-    repo.seedCommit(
-      "gtd(agent): polishing → idle\n\nGtd-Step: polishing#1\nGtd-Version: 0.0.1\nGtd-Format: 1",
-    )
-    const { exitCode, stdout, stderr } = await run(repo, "summary", "--slice", "verify")
-    expect(exitCode).toBe(0)
-    expect(stderr).toContain("recorded by gtd 0.0.1")
-    expect(stdout).toContain("verify 2/2")
-  })
-})
-
 describe("gtd base — prints the review anchor hash", () => {
   // Each round's review window starts at the commit that entered `deciding`;
   // FEEDBACK.md sends the process round again, a clean accept finishes it.

package/src/cli/Program.ts

@@ -43,8 +43,6 @@ import {
   type StatusChange,
   selectPath,
   EXIT_OK,
-  renderSlicesJson,
-  slicesDocument,
 } from "../wire/index.js"
 import {
   currentRest,
@@ -53,7 +51,6 @@ import {
   renderRest,
   restAt,
   previewLanding,
-  processSlices,
   noProcessUnderway,
   restIsIdle,
   reviewBaseFor,
@@ -148,7 +145,6 @@ export type Command =
     }
   | { readonly kind: "door"; readonly name: string; readonly args: readonly string[] }
   | { readonly kind: "doors" }
-  | { readonly kind: "slices" }
   | { readonly kind: "abandon" }
   | { readonly kind: "restore" }
   | { readonly kind: "next" }
@@ -163,13 +159,7 @@ export type Command =
     }
   | { readonly kind: "uncheck"; readonly file: string }
   | { readonly kind: "install" }
-  | {
-      readonly kind: "contextHook"
-      readonly soft?: number
-      readonly hard?: number
-      readonly window?: number
-    }
-  | { readonly kind: "summary"; readonly slice?: string }
+  | { readonly kind: "summary" }
   | { readonly kind: "base" }
   | { readonly kind: "judge" }
   | { readonly kind: "judgeAnswer" }
@@ -337,21 +327,12 @@ const planLanding = (
  * closes or sits inside its own closing message. Writes nothing — no git, no
  * state transition, no file. Refuses (throws, mapped to the runtime-error
  * exit code) when the workflow declares no `summary` prompt, or the resolved
- * run has no commits to name. `--slice` also refuses an unknown slice name
- * (listing the valid slices), a config edited since the process closed, and a
- * replay that diverged. The edge never narrates: the CLI prints the
- * version warning, before the unknown-slice refusal; a replay refusal carries
- * it in its message.
+ * run has no commits to name.
  */
-const runSummaryCommand = (
-  out: ArtifactOut,
-  sliceName: string | undefined,
-): Effect.Effect<void, Error, CommandRequirements> =>
+const runSummaryCommand = (out: ArtifactOut): Effect.Effect<void, Error, CommandRequirements> =>
   Effect.gen(function* () {
     const run = yield* summaryRun
-    const { prompt, versionWarning, unknownSlice } = yield* summaryFor(run, sliceName)
-    if (versionWarning !== undefined) yield* (yield* Narrator).warn(versionWarning)
-    if (unknownSlice !== undefined) return yield* Effect.fail(new Error(unknownSlice))
+    const { prompt } = yield* summaryFor(run)
     if (prompt === undefined) {
       return yield* Effect.fail(
         new Error(
@@ -445,24 +426,6 @@ const readStdin = (): Effect.Effect<string, Error> =>
     catch: (e) => (e instanceof Error ? e : new Error(String(e))),
   })
 
-/** Stdout is written once: a hook reads one JSON document, or none. */
-const runContextHookCommand = (
-  command: Extract<Command, { kind: "contextHook" }>,
-  out: ArtifactOut,
-): Effect.Effect<void, Error, ToolCommands> =>
-  Effect.gen(function* () {
-    const tools = yield* ToolCommands
-    const input = yield* readStdin()
-    out.write(
-      yield* tools.contextHook({
-        input,
-        ...(command.soft !== undefined ? { soft: command.soft } : {}),
-        ...(command.hard !== undefined ? { hard: command.hard } : {}),
-        ...(command.window !== undefined ? { window: command.window } : {}),
-      }),
-    )
-  })
-
 /** Stdout is written once, after the answerer resolves — a rejection leaves it empty. */
 const runJudgeRunCommand = (
   command: Extract<Command, { kind: "judgeRun" }>,
@@ -701,22 +664,6 @@ const runDoorsCommand = (
     else yield* writeSelection(out, document, json.path)
   })
 
-const runSlicesCommand = (
-  json: JsonMode,
-  out: ArtifactOut,
-): Effect.Effect<void, Error, CommandRequirements> =>
-  Effect.gen(function* () {
-    const { slices, versionWarning } = yield* processSlices
-    if (versionWarning !== undefined) yield* (yield* Narrator).warn(versionWarning)
-    if (json.kind === "off") {
-      out.write(slices.map((s) => `${s.name} ${s.base}..${s.tip}\n`).join(""))
-      return
-    }
-    const document = slicesDocument(slices)
-    if (json.kind === "document") out.write(renderSlicesJson(document))
-    else yield* writeSelection(out, document, json.path)
-  })
-
 /**
  * Ends the process underway without completing it. Nothing is discarded: a
  * `git reset --mixed` to the process's start commit leaves every turn
@@ -1217,7 +1164,6 @@ export const needsOf = (kind: Command["kind"]): Needs => {
   switch (kind) {
     case "lsp":
     case "install":
-    case "contextHook":
     case "judgeRun":
     case "strays":
       return "none"
@@ -1235,7 +1181,6 @@ export const standaloneKinds = (): readonly Command["kind"][] => [
   "check",
   "uncheck",
   "install",
-  "contextHook",
   "judgeRun",
   "strays",
 ]
@@ -1281,8 +1226,6 @@ const dispatchVoidCommand = (
       return runDoorCommand(command.name, command.args, out)
     case "doors":
       return runDoorsCommand(json, out)
-    case "slices":
-      return runSlicesCommand(json, out)
     case "abandon":
       return runAbandonCommand(out)
     case "restore":
@@ -1305,10 +1248,8 @@ const dispatchVoidCommand = (
       return runUncheckCommand(command.file)
     case "install":
       return runInstallCommand(out)
-    case "contextHook":
-      return runContextHookCommand(command, out)
     case "summary":
-      return runSummaryCommand(out, command.slice)
+      return runSummaryCommand(out)
     case "base":
       return runBaseCommand(out)
     case "judge":

package/src/cli/ToolCommands.ts

@@ -1,7 +1,6 @@
 import { Context } from "effect"
 import type { Effect } from "effect"
 import type { UiSettings } from "../flows/index.js"
-import type { ContextHookRequest } from "../wire/index.js"
 
 /** How to run THIS gtd — a tool (the LSP) never reads a different version's state than the one it ships with. */
 export type SelfGtd = readonly [string, ...string[]]
@@ -38,8 +37,6 @@ export class ToolCommands extends Context.Tag("ToolCommands")<
       out: { readonly write: (chunk: string) => void; readonly flush: () => void },
     ) => Effect.Effect<void, Error>
     readonly lsp: (gtd: SelfGtd) => Effect.Effect<void, Error>
-    /** The hook's stdout: a JSON document, or empty to let the turn go on. */
-    readonly contextHook: (request: ContextHookRequest) => Effect.Effect<string, Error>
     readonly judge: (request: JudgeRequest) => Promise<string>
   }
 >() {}