@pmelab/gtd 64.1.1 → 64.2.0

package/dist/wire.mjs

@@ -1,2 +1 @@
-import { A as UNATTRIBUTED_MODEL, C as EXIT_RUNTIME_ERROR, D as EXIT_USAGE_ERROR, E as EXIT_STRAYS_FOUND, M as renderFormat, O as ACCESS_REFUSAL, S as EXIT_OK, T as EXIT_SIGTERM, _ as BEAT_KINDS, a as renderScriptJson, b as stallDiagnosis, c as landProseText, d as renderLandPlain, f as DEMAND_BRIEFING, g as statusOf, h as renderBeatJson, i as judgeJson, j as WIRE_SCHEMA, k as PIN_PATH, l as noopText, m as beatDocument, n as resolveSession, o as scriptFields, p as renderBeatPlain, r as selectPath, s as landFields, t as globMatches, u as renderLandJson, v as beatKindOf, w as EXIT_SIGINT, x as EXIT_CODES, y as demandOf } from "./chunks/wire-CPNSm_9N.mjs";
-export { ACCESS_REFUSAL, BEAT_KINDS, DEMAND_BRIEFING, EXIT_CODES, EXIT_OK, EXIT_RUNTIME_ERROR, EXIT_SIGINT, EXIT_SIGTERM, EXIT_STRAYS_FOUND, EXIT_USAGE_ERROR, PIN_PATH, UNATTRIBUTED_MODEL, WIRE_SCHEMA, beatDocument, beatKindOf, demandOf, globMatches, judgeJson, landFields, landProseText, noopText, renderBeatJson, renderBeatPlain, renderFormat, renderLandJson, renderLandPlain, renderScriptJson, resolveSession, scriptFields, selectPath, stallDiagnosis, statusOf };
+export { O as ACCESS_REFUSAL, _ as BEAT_KINDS, f as DEMAND_BRIEFING, x as EXIT_CODES, S as EXIT_OK, C as EXIT_RUNTIME_ERROR, w as EXIT_SIGINT, T as EXIT_SIGTERM, E as EXIT_STRAYS_FOUND, D as EXIT_USAGE_ERROR, k as PIN_PATH, A as UNATTRIBUTED_MODEL, j as WIRE_SCHEMA, m as beatDocument, v as beatKindOf, y as demandOf, t as globMatches, i as judgeJson, s as landFields, c as landProseText, l as noopText, h as renderBeatJson, p as renderBeatPlain, M as renderFormat, u as renderLandJson, d as renderLandPlain, a as renderScriptJson, n as resolveSession, o as scriptFields, r as selectPath, b as stallDiagnosis, g as statusOf } from "./chunks/wire-CaPJ9Tme.mjs";

package/dist/workflow-kit.mjs

@@ -1,6 +1,6 @@
-import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-B7ZRCe-B.mjs";
-import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-Cem5i6Xl.mjs";
-//#region src/workflow-kit/health.ts
+import { B as head, F as changesSince, G as mark, P as changes, X as read, Z as refuse, d as hasThreadFor, et as scope, g as requireReplies, v as requireThreadsClosed } from "./chunks/flows-dnIE_qbe.mjs";
+import { C as reviewRisks, N as parseThreads, S as reviewNotes, T as unansweredNotes, n as stripCodeThreads, x as reviewDecisions } from "./chunks/steering-DEh_MS40.mjs";
+// src/workflow-kit/health.ts
 /** Hand a red suite that repeated attempts could not fix to a person, until `limit` rounds are spent. */
 const escalation = async (count, steps) => {
 	if (count.rounds >= steps.limit) return steps.exhausted();
@@ -74,8 +74,7 @@ const healthy = async (fix, health) => {
 const gate = (name, passes, blocked) => scope(name, async () => {
 	while (!await passes()) await blocked();
 });
-//#endregion
-//#region src/workflow-kit/quality.ts
+// src/workflow-kit/quality.ts
 const lensOf = (entry) => {
 	const at = entry.indexOf("=");
 	return at < 0 ? {
@@ -106,8 +105,7 @@ const fixFindings = async (f) => {
 	await f.escalate();
 	return false;
 };
-//#endregion
-//#region src/workflow-kit/scenarios.ts
+// src/workflow-kit/scenarios.ts
 const DOC_STRING = /^("""|```)/;
 const THEN = /^Then\s/;
 const CONTINUATION = /^(And|But|\*)\s/;
@@ -161,8 +159,7 @@ const removedAssertions = (changes) => changes.filter((c) => c.path.endsWith(".f
 		lines
 	};
 }).filter((r) => r.lines.length > 0);
-//#endregion
-//#region src/workflow-kit/review.ts
+// src/workflow-kit/review.ts
 const collect = async (p, capture, round, requested) => {
 	await p.collecting(capture, round);
 	if (read(p.feedback) !== void 0) return "feedback";
@@ -426,5 +423,4 @@ const reviewToHandOff = async (base, p) => {
 		return;
 	}
 };
-//#endregion
 export { assertionLines, escalation, fixFindings, gate, healthy, lensEntriesOf, lensOf, lensScopes, lensesOf, qualityLap, removedAssertions, review, reviewToHandOff, untilSettled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "64.1.1",
+  "version": "64.2.0",
   "private": false,
   "description": "Git-aware CLI that emits the next prompt for an autonomous coding agent based on the current repository state",
   "bin": {
@@ -83,33 +83,17 @@
   "scripts": {
     "prepare": "husky",
     "dev": "node dev/run.mjs",
-    "build": "tsdown --filter web && npx @tailwindcss/cli -i src/web/styles.css -o dist/web/main.css --minify && node scripts/inline-web-client.mjs && tsdown --filter gtd --filter core && tsdown --filter entrypoints",
-    "postbuild": "node scripts/assert-no-test-doubles.mjs",
-    "watch": "tsdown --watch",
+    "watch": "vp pack --watch",
     "bench:replay": "node scripts/bench-replay.mjs",
     "test": "jiti scripts/test-states.main.ts",
-    "test:unit": "vitest run --project unit",
-    "test:workflows": "vitest run --project workflows",
     "test:watch": "vitest",
     "test:changed": "vitest run --project unit --project e2e-inmem --project workflows --changed HEAD",
-    "test:e2e": "npm run test:e2e:inmem && npm run test:e2e:live",
-    "typecheck": "tsc --noEmit && tsc --noEmit -p src/web/tsconfig.json",
-    "lint": "oxlint .",
-    "lint:sh": "jiti scripts/generate-shell-corpus.ts --check && shellcheck -s sh tests/shell/corpus/*.sh",
-    "lint:boundaries": "depcruise src tests claude",
-    "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
+    "test:e2e": "vp run test:e2e:inmem && vp run test:e2e:live",
+    "format": "vp fmt",
     "test:mutation": "stryker run",
-    "test:e2e:inmem": "vitest run --project e2e-inmem",
-    "test:e2e:live": "vitest run --project e2e-live --no-file-parallelism",
-    "analyze": "fallow --summary --quiet",
-    "test:web": "vitest run --project storybook",
     "storybook": "storybook dev --host 0.0.0.0",
     "coverage": "vitest run --project unit --coverage"
   },
-  "lint-staged": {
-    "*": "oxfmt --no-error-on-unmatched-pattern --write"
-  },
   "devDependencies": {
     "@commitlint/cli": "^21.2.3",
     "@commitlint/config-conventional": "^21.2.3",
@@ -119,8 +103,8 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^12.0.8",
     "@semantic-release/npm": "^12.0.0",
-    "@storybook/addon-vitest": "^10.6.0",
-    "@storybook/react-vite": "^10.6.0",
+    "@storybook/addon-vitest": "^10.6.5",
+    "@storybook/react-vite": "^10.6.5",
     "@stryker-mutator/core": "^9.6.1",
     "@stryker-mutator/typescript-checker": "^9.6.1",
     "@stryker-mutator/vitest-runner": "^9.6.1",
@@ -134,29 +118,27 @@
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^5.2.0",
-    "@vitest/browser": "^4.1.12",
-    "@vitest/browser-playwright": "^4.1.12",
-    "@vitest/coverage-v8": "^4.1.12",
+    "@vitest/browser": "5.0.5",
+    "@vitest/browser-playwright": "5.0.5",
+    "@vitest/coverage-v8": "5.0.5",
     "dependency-cruiser": "^18.3.1",
     "fallow": "3.25.0",
     "fast-check": "^4.8.0",
     "husky": "^9.1.7",
     "jiti": "^2.7.0",
-    "lint-staged": "^17.0.8",
-    "oxfmt": "^0.59.0",
-    "oxlint": "^1.74.0",
+    "oxfmt": "0.59.0",
+    "oxlint": "1.74.0",
     "playwright": "^1.62.1",
     "prettier": "^3.8.1",
     "quickpickle": "1.11.2",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "semantic-release": "^25.0.5",
-    "storybook": "^10.6.0",
+    "storybook": "^10.6.5",
     "tailwind-merge": "^3.7.0",
     "tailwindcss": "^4.3.3",
-    "tsdown": "^0.22.8",
-    "turbo": "^2.10.9",
-    "vitest": "^4.1.12",
+    "vite-plus": "1.4.0",
+    "vitest": "5.0.5",
     "yaml": "^2.8.2",
     "zustand": "^5.0.15"
   },
@@ -190,5 +172,10 @@
     "rolldown": "^1.1.5",
     "vscode-languageserver": "^10.1.0",
     "vscode-languageserver-textdocument": "^1.0.13"
+  },
+  "overrides": {
+    "storybook": {
+      "vite-plus": "$vite-plus"
+    }
   }
 }

package/src/cli/Cli.test.ts

@@ -32,6 +32,7 @@ const FLAG_NAMES = [
   "--port",
   "--host",
   "--self-signed",
+  "--http",
   "--dev",
   "--cost",
   "--model",

package/src/cli/Cli.ts

@@ -184,7 +184,7 @@ const FLAGS: readonly FlagRow[] = [
     },
     scopeError: "gtd: --port is only valid for `gtd ui`",
     valueHint: "<n>",
-    help: "The tailscale serve port (default: the first free of 8443, 10000, 443), or with --host the port to bind (default: any free one)",
+    help: "The tailscale serve port (default: the first free of 8443, 10000, 443), or with --host or --http the port to bind (default: any free one)",
   },
   {
     name: "--host",
@@ -209,6 +209,16 @@ const FLAGS: readonly FlagRow[] = [
     valueHint: "",
     help: "Bind directly with a throwaway self-signed certificate instead of the configured ui.cert/ui.key",
   },
+  {
+    name: "--http",
+    arity: 0,
+    repeatable: false,
+    scope: (kind) => kind === "ui",
+    decode: () => Result.succeed(true),
+    scopeError: "gtd: --http is only valid for `gtd ui`",
+    valueHint: "",
+    help: "Serve plain HTTP for a local TLS-terminating proxy; binds 127.0.0.1 unless a loopback --host is given",
+  },
   {
     name: "--dev",
     arity: 0,
@@ -1137,6 +1147,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
     readonly "--spec"?: string
     readonly "--host"?: string
     readonly "--self-signed"?: boolean
+    readonly "--http"?: boolean
     readonly "--dev"?: boolean
     readonly "--provider"?: "fixed" | "jev" | "llm"
     readonly "--answers"?: string
@@ -1185,6 +1196,9 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
   }
 
   if (kind === "ui") {
+    if (bag["--http"] === true && bag["--self-signed"] === true) {
+      return usagePlan("gtd: --http and --self-signed cannot be combined", jsonSeen)
+    }
     return {
       kind: "command",
       command: {
@@ -1192,6 +1206,7 @@ export const parseArgv = (argv: readonly string[]): CliPlan => {
         ...(bag["--host"] !== undefined ? { host: bag["--host"] } : {}),
         ...(bag["--port"] !== undefined ? { port: bag["--port"] } : {}),
         selfSigned: bag["--self-signed"] ?? false,
+        ...(bag["--http"] === true ? { http: true } : {}),
         dev: bag["--dev"] ?? false,
       },
       json,

package/src/cli/Program.ts

@@ -51,6 +51,7 @@ import {
 } from "../wire/index.js"
 import {
   currentRest,
+  refuseHugeUntracked,
   repinAnchor,
   startRefusal,
   currentRun,
@@ -144,6 +145,7 @@ export type Command =
       readonly host?: string
       readonly port?: number
       readonly selfSigned: boolean
+      readonly http?: boolean
       readonly dev: boolean
     }
   | {
@@ -310,6 +312,7 @@ const planLanding = (
   current?: Rest,
 ): Effect.Effect<LandResult, Error, CommandRequirements> =>
   Effect.gen(function* () {
+    yield* refuseHugeUntracked
     const rest = current ?? (yield* currentRest)
     const snapshot = yield* snapshotFromRest(rest, opts.judge)
     const outcome = planStepPure(snapshot, opts)
@@ -596,6 +599,7 @@ const startWorkflow = (
         new GtdUsageError(`${commandLabel}: unknown workflow "${workflow}" — ${startable}`),
       )
     }
+    yield* refuseHugeUntracked
     const rest = yield* restAt(undefined, varOverrides)
     const started = yield* startRefusal(rest, resolved, varOverrides)
     const plan = yield* planStart(
@@ -967,6 +971,7 @@ const runNextCommand = (
   out: ArtifactOut,
 ): Effect.Effect<void, Error, CommandRequirements> =>
   Effect.gen(function* () {
+    yield* refuseHugeUntracked
     const rest = yield* currentRest
     const rendered = yield* renderRest(rest)
     const fields = yield* gatherBeatDocument(rest, rendered)
@@ -1260,6 +1265,7 @@ const runUiCliCommand = (
           ...(command.host !== undefined ? { host: command.host } : {}),
           ...(command.port !== undefined ? { port: command.port } : {}),
           selfSigned: command.selfSigned,
+          ...(command.http === true ? { http: true } : {}),
           dev: command.dev,
         },
         config: config.ui,

package/src/cli/ToolCommands.ts

@@ -8,6 +8,7 @@ export interface UiRequest {
     readonly host?: string
     readonly port?: number
     readonly selfSigned: boolean
+    readonly http?: boolean
     readonly dev: boolean
   }
   readonly config: UiSettings | undefined

package/src/edge/Edge.test.ts

@@ -6,6 +6,7 @@ import {
   currentRun,
   historyTrail,
   noProcessUnderway,
+  refuseHugeUntracked,
   renderRest,
   restAt,
   restIsIdle,
@@ -757,7 +758,7 @@ describe("restAt", () => {
         `--model=${model}`,
       )
       expect(exitCode).toBe(0)
-      await applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
+      applied(repo, (JSON.parse(stdout) as { readonly script: string }).script)
       await takePinBeat(repo, "add")
     }
     const { cost } = await provide(currentRest, repo)
@@ -768,6 +769,27 @@ describe("restAt", () => {
     ])
   })
 
+  it("refuses over 1000 untracked files and proceeds at exactly 1000", async () => {
+    const repo = repoWith(LINEAR)
+    const files = (n: number) =>
+      Object.fromEntries(Array.from({ length: n }, (_, i) => [`big/f${i}.txt`, "x\n"]))
+    write(repo, files(1000))
+    await provide(refuseHugeUntracked, repo)
+    write(repo, files(1001))
+    await expect(provide(refuseHugeUntracked, repo)).rejects.toThrow(
+      /1001 untracked files.*big \(1001\).*\.gitignore/,
+    )
+  })
+
+  it("resolving the current rest never refuses a huge untracked tree", async () => {
+    const repo = repoWith(LINEAR)
+    write(
+      repo,
+      Object.fromEntries(Array.from({ length: 1001 }, (_, i) => [`big/f${i}.txt`, "x\n"])),
+    )
+    expect((await provide(currentRest, repo)).changes).toHaveLength(1001)
+  })
+
   it("restAt(ref) resolves where the process rested at that commit", async () => {
     const repo = repoWith(LINEAR)
     const boundary = headOf(repo)

package/src/edge/Edge.ts

@@ -238,7 +238,7 @@ const historyFormatFault = (history: History, location: EpisodeLocation): string
 const runOf = (
   history: History,
   location: EpisodeLocation,
-  closingHash: string | undefined = undefined,
+  closingHash?: string,
 ): Effect.Effect<ProcessRun, Error> => {
   const fault = historyFormatFault(history, location)
   return fault === undefined
@@ -971,6 +971,28 @@ const setupFor = (
     return { resolved, def, vars, env, setup }
   })
 
+const UNTRACKED_LIMIT = 1000
+
+// `git add -A` would commit every untracked file, so a huge tree is refused —
+// only by the commands that land (next, land, judge answer, start). Read-only
+// rest readers never refuse.
+export const refuseHugeUntracked = Effect.gen(function* () {
+  const paths = yield* (yield* GitService).untrackedPaths()
+  if (paths.length <= UNTRACKED_LIMIT) return
+  const dirs = new Map<string, number>()
+  for (const p of paths) {
+    const i = p.lastIndexOf("/")
+    const d = i === -1 ? "." : p.slice(0, i)
+    dirs.set(d, (dirs.get(d) ?? 0) + 1)
+  }
+  const top = [...dirs].sort((a, b) => b[1] - a[1]).slice(0, 3)
+  return yield* Effect.fail(
+    new Error(
+      `gtd: ${paths.length} untracked files (limit ${UNTRACKED_LIMIT}); largest untracked directories: ${top.map(([d, n]) => `${d} (${n})`).join(", ")}. Add them to .gitignore or delete them.`,
+    ),
+  )
+})
+
 // Only an approval gate counts an index-only edit (one staged, then reverted
 // in the worktree): its approval must cover exactly the judged diff. Every
 // other rest keeps the worktree's view, so a net-zero turn stays an attempt.

package/src/edge/index.ts

@@ -3,6 +3,7 @@ export {
   summaryRun,
   restAt,
   currentRest,
+  refuseHugeUntracked,
   repinAnchor,
   startRefusal,
   reviewBaseFor,

package/src/emit/GitScript.test.ts

@@ -234,7 +234,7 @@ describe("shellQuote", () => {
   })
 
   // 500 samples through 500 bash spawns starved the 30s test timeout whenever
-  // the suite ran under turbo's parallel task load. The property is unchanged;
+  // the suite ran under `npm test`'s parallel task load. The property is unchanged;
   // all samples now round-trip through a SINGLE bash, NUL-delimited on the way
   // back out (NUL is filtered from the inputs, so it can't collide).
   it("round-trips arbitrary strings — including newlines and non-ASCII — through a real bash printf", () => {

package/src/flows/runtime.test.ts

@@ -146,7 +146,7 @@ describe("kept()", () => {
 })
 
 /** A context that records every step request and resolves it with `reply`. */
-const recording = (reply: unknown = undefined) => {
+const recording = (reply?: unknown) => {
   const requests: StepRequest[] = []
   installContext({
     step: async (request: StepRequest) => {

package/src/platform/Git.ts

@@ -94,6 +94,8 @@ export interface GitReaderOperations {
   readonly changedPaths: (
     base?: string,
   ) => Effect.Effect<ReadonlyArray<{ readonly path: string; readonly status: string }>, Error>
+  /** Untracked, non-ignored paths. */
+  readonly untrackedPaths: () => Effect.Effect<ReadonlyArray<string>, Error>
   /**
    * The index vs `HEAD`, as `{path, status}` pairs — what a commit would carry
    * that `changedPaths` misses when the worktree reverted a staged edit. Empty
@@ -205,6 +207,14 @@ const stripCommitSeam = (tail: string): string => {
 
 type GitExec = (...args: [string, ...Array<string>]) => Effect.Effect<string, Error>
 
+// Unbounded argv throws E2BIG synchronously (a defect), so path lists are chunked.
+const ARGV_CHUNK = 500
+const chunked = <T>(items: ReadonlyArray<T>): Array<ReadonlyArray<T>> => {
+  const out: Array<ReadonlyArray<T>> = []
+  for (let i = 0; i < items.length; i += ARGV_CHUNK) out.push(items.slice(i, i + ARGV_CHUNK))
+  return out
+}
+
 /**
  * `path → blob object id` at `ref`; a path absent from the map doesn't exist
  * there. An unresolvable `ref` (an empty repo) yields an empty map, so every
@@ -215,11 +225,17 @@ const blobsAtRef = (
   ref: string,
   paths: ReadonlyArray<string>,
 ): Effect.Effect<Map<string, string>, Error> =>
-  exec("git", "ls-tree", "-r", "-z", ref, "--", ...paths).pipe(
-    Effect.catch(() => Effect.succeed("")),
-    Effect.map((out) => {
+  Effect.forEach(
+    chunked(paths),
+    (chunk) =>
+      exec("git", "ls-tree", "-r", "-z", ref, "--", ...chunk).pipe(
+        Effect.catch(() => Effect.succeed("")),
+      ),
+    { concurrency: 1 },
+  ).pipe(
+    Effect.map((outs) => {
       const blobs = new Map<string, string>()
-      for (const entry of splitNul(out)) {
+      for (const entry of outs.flatMap(splitNul)) {
         const tab = entry.indexOf("\t")
         if (tab === -1) continue
         const [, type, oid] = entry.slice(0, tab).split(" ")
@@ -246,16 +262,20 @@ const hashObjects = (
   exec: GitExec,
   paths: ReadonlyArray<string>,
 ): Effect.Effect<Map<string, string>, Error> =>
-  exec("git", "hash-object", "--", ...paths).pipe(
-    Effect.map(
-      (out) =>
-        new Map(
+  Effect.forEach(
+    chunked(paths),
+    (chunk) =>
+      exec("git", "hash-object", "--", ...chunk).pipe(
+        Effect.map((out) =>
           out
             .trim()
             .split("\n")
-            .map((oid, i) => [paths[i] ?? "", oid.trim()] as const),
+            .map((oid, i) => [chunk[i] ?? "", oid.trim()] as const),
         ),
-    ),
+      ),
+    { concurrency: 1 },
+  ).pipe(
+    Effect.map((entries) => new Map(entries.flat())),
     Effect.catch(() => Effect.succeed(new Map<string, string>())),
   )
 
@@ -471,6 +491,9 @@ const makeGitImpl = (
         return all
       }),
 
+    untrackedPaths: () =>
+      exec("git", "ls-files", "--others", "--exclude-standard", "-z").pipe(Effect.map(splitNul)),
+
     stagedPaths: () =>
       exec("git", "diff", "--cached", "--name-status", "--no-renames", "-z", "HEAD").pipe(
         Effect.catch(() => Effect.succeed("")),

package/src/replay/Replay.test.ts

@@ -370,7 +370,9 @@ describe("replay", () => {
     })
 
     it("is reported when history continues past the end of the flow", async () => {
-      const short = async () => void (await human("only"))
+      const short = async () => {
+        await human("only")
+      }
       const h = new History().land("human", "only", 1, "only").land("human", "only", 2, "only")
       expect((await replayOf(short, h)).kind).toBe("divergence")
     })
@@ -606,7 +608,9 @@ describe("replay", () => {
   })
 
   it("ends the episode on return and on restart", async () => {
-    const returning = async () => void (await human("only"))
+    const returning = async () => {
+      await human("only")
+    }
     const h = new History().land("human", "only", 1, "only")
     expect(await replayOf(returning, h)).toMatchObject({ kind: "ended", via: "return" })
 
@@ -1337,7 +1341,9 @@ describe("replay: a repin's anchor", () => {
   })
 
   it("diverges when the flow ends where it names a step", async () => {
-    const outcome = await replayOf(async () => void (await human("idle")), anchoredHistory())
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, anchoredHistory())
     expect(outcome).toMatchObject({ kind: "divergence", at: hashOf(3), reached: undefined })
   })
 
@@ -1346,7 +1352,9 @@ describe("replay: a repin's anchor", () => {
       .land("human", "idle", 1, "build", { "a.txt": "a" })
       .land("agent", "build", 1, "old")
       .raw(anchorTo("gtd:unpin", 1))
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind).toBe("ended")
   })
 
@@ -1355,13 +1363,17 @@ describe("replay: a repin's anchor", () => {
       .land("human", "idle", 1, "build", { "a.txt": "a" })
       .land("agent", "build", 1, "old")
       .raw(`gtd(check): pin → unpin\n\nGtd-Pin: add\nGtd-Anchor: ${hashOf(1)}\nGtd-Format: 3`)
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind).toBe("ended")
   })
 
   it("reads a format 4 anchor naming unpin as a step", async () => {
     const outcome = await replayOf(
-      async () => void (await human("idle")),
+      async () => {
+        await human("idle")
+      },
       new History()
         .land("human", "idle", 1, "build", { "a.txt": "a" })
         .land("agent", "build", 1, "old")
@@ -1372,7 +1384,9 @@ describe("replay: a repin's anchor", () => {
 
   it("fails when it names no commit replay reads", async () => {
     const h = anchoredHistory().raw(anchorTo("build", 2))
-    const outcome = await replayOf(async () => void (await human("idle")), h)
+    const outcome = await replayOf(async () => {
+      await human("idle")
+    }, h)
     expect(outcome.kind === "failed" && outcome.message).toContain(
       "which is no commit replay reads",
     )

package/src/steering/Blocks.test.ts

@@ -35,7 +35,9 @@ describe("blockRunInline — spec-feedback regression: a nested list item's own
     const nodes = blockNodesOf(content, tree)
     const topItem = nodes[0]?.block?.items?.[0]
     expect(topItem?.inline).toEqual([{ kind: "text", value: "outer" }])
-    expect(topItem?.items).toEqual([{ text: "inner", inline: [{ kind: "text", value: "inner" }] }])
+    expect(topItem?.items).toEqual([
+      { text: "inner", inline: [{ kind: "text", value: "inner" }], line: 1 },
+    ])
   })
 })
 

package/src/steering/Blocks.ts

@@ -128,21 +128,28 @@ const nodeInline = (
   return title.length > 0 ? [{ kind: "text", value: title }] : []
 }
 
+type NoteAt = ReturnType<typeof noteLookup>
+
 /** One list item as a `BlockListItem`, recursing into a nested `list` child (there is at most one, CommonMark's own shape) as its own `items`. */
-const blockListItemOf = (content: string, item: ListItem): BlockListItem => {
+const blockListItemOf = (content: string, item: ListItem, noteAt: NoteAt): BlockListItem => {
   const nested = item.children.filter((c): c is List => c.type === "list")
-  const items = nested.flatMap((list) => blockListItemsOf(content, list.children))
+  const items = nested.flatMap((list) => blockListItemsOf(content, list.children, noteAt))
+  const line = item.position === undefined ? undefined : toLspPosition(item.position.start).line
   return {
     text: listItemText(content, item),
     inline: listItemInline(content, item),
     ...(item.checked === true || item.checked === false ? { checked: item.checked } : {}),
     ...(items.length > 0 ? { items } : {}),
+    ...(line === undefined ? {} : { line, ...noteAt(line) }),
   }
 }
 
 /** Every item of a `list` node's own `children`, as `BlockListItem`s, in document order. */
-const blockListItemsOf = (content: string, items: readonly ListItem[]): readonly BlockListItem[] =>
-  items.map((item) => blockListItemOf(content, item))
+const blockListItemsOf = (
+  content: string,
+  items: readonly ListItem[],
+  noteAt: NoteAt,
+): readonly BlockListItem[] => items.map((item) => blockListItemOf(content, item, noteAt))
 
 /** The `title` an empty fenced code block (a `` ``` ``/`` ``` `` pair with nothing between them) falls back to — its real body is `""`, and every node still carries a non-empty title. */
 const EMPTY_CODE_BLOCK_TITLE = "(empty code block)"
@@ -184,6 +191,7 @@ const blockTitle = (content: string, node: RootContent, options?: BlockWalkOptio
 const blockOf = (
   content: string,
   node: RootContent,
+  noteAt: NoteAt,
   options?: BlockWalkOptions,
 ): SteeringViewNode["block"] | undefined => {
   switch (node.type) {
@@ -197,7 +205,7 @@ const blockOf = (
       return {
         kind: "list",
         ordered: node.ordered === true,
-        items: blockListItemsOf(content, visibleListItems(node, options)),
+        items: blockListItemsOf(content, visibleListItems(node, options), noteAt),
       }
     case "code":
       return {
@@ -285,7 +293,7 @@ export const blockNodesOfRun = (
   const noteAt = noteLookup(content, options?.footnotes)
   return visibleNodes(content, nodes, options).map((node) => {
     const startLine = toLspPosition(node.position!.start).line
-    const block = blockOf(content, node, options)
+    const block = blockOf(content, node, noteAt, options)
     return {
       title: blockTitle(content, node, options),
       anchor: { kind: "paragraph" as const, line: startLine },

package/src/steering/SteeringFormat.ts

@@ -74,10 +74,13 @@ export type SteeringAnchor =
   | { readonly kind: "option"; readonly questionIndex: number; readonly index: number }
   | { readonly kind: "paragraph"; readonly line: number }
 
+/** `pick-never-clears`: a free-form pick-one tick only moves, so `checked: false` is refused by policy, not for a bad anchor. */
+type SteeringRefusalReason = "anchor-not-found" | "id-collision" | "pick-never-clears"
+
 /** `annotate`'s result: the edits to splice in, or a typed refusal — a stale/unresolvable `anchor`, or a derived note id that already names a definition. */
 export type SteeringAnnotateResult =
   | { readonly ok: true; readonly edits: readonly SteeringEdit[] }
-  | { readonly ok: false; readonly reason: "anchor-not-found" | "id-collision" }
+  | { readonly ok: false; readonly reason: SteeringRefusalReason }
 
 /** One item of a `list` block's `items` tree — recursive to whatever depth the source markdown nests. */
 export interface BlockListItem {
@@ -89,6 +92,11 @@ export interface BlockListItem {
   readonly items?: readonly BlockListItem[]
   /** `text`'s own inline structure — the shared renderer walks this instead of `text` when present. Populated at every nesting depth. */
   readonly inline?: readonly InlineNode[]
+  /** The item's own 0-based source line: a `paragraph` anchor at it notes this item alone. */
+  readonly line?: number
+  /** The note or thread whose marker sits on `line`, as on a view node. */
+  readonly note?: string
+  readonly thread?: SteeringViewThread
 }
 
 export interface SteeringViewThread {