@pmelab/gtd 64.1.2 → 64.3.0

package/dist/steering.mjs

@@ -1 +1 @@
-export { g as ANSWER_FIX, _ as ANSWER_LEAD, v as ANSWER_WONT_FIX, O as FIX_BOX, E as FREE_TEXT_PLACEHOLDER, k as NOISE_HEADING, y as REVIEW_SECTIONS, h as applySteeringEdits, A as findingEntries, I as formatFinding, m as freeFormFormat, D as isAnswered, f as listFormat, r as openQuestions, j as openThreadFindings, c as openThreads, t as parseCodeThreads, M as parseFootnotes, N as parseThreads, P as parseThreadsWithFindings, b as reviewChunks, x as reviewDecisions, S as reviewNotes, C as reviewRisks, w as reviewSections, i as sectionBodies, p as sectionFormat, a as sections, l as steeringFormatFor, n as stripCodeThreads, o as threads, T as unansweredNotes } from "./chunks/steering-CQzL-lX1.mjs";
+export { g as ANSWER_FIX, _ as ANSWER_LEAD, v as ANSWER_WONT_FIX, O as FIX_BOX, E as FREE_TEXT_PLACEHOLDER, k as NOISE_HEADING, y as REVIEW_SECTIONS, h as applySteeringEdits, A as findingEntries, I as formatFinding, m as freeFormFormat, D as isAnswered, f as listFormat, r as openQuestions, j as openThreadFindings, c as openThreads, t as parseCodeThreads, M as parseFootnotes, N as parseThreads, P as parseThreadsWithFindings, b as reviewChunks, x as reviewDecisions, S as reviewNotes, C as reviewRisks, w as reviewSections, i as sectionBodies, p as sectionFormat, a as sections, l as steeringFormatFor, n as stripCodeThreads, o as threads, T as unansweredNotes } from "./chunks/steering-DEh_MS40.mjs";

package/dist/testkit/gherkin.mjs

@@ -1,4 +1,4 @@
-import { n as runsItsScript, r as testRepo } from "../chunks/testkit-D539mnDI.mjs";
+import { n as runsItsScript, r as testRepo } from "../chunks/testkit-BUX-47TD.mjs";
 import { pathToFileURL } from "node:url";
 import { resolve } from "node:path";
 import { After, AfterAll, Given, QuickPickleWorld, Then, When, setWorldConstructor } from "quickpickle";

package/dist/testkit.mjs

@@ -1,3 +1,3 @@
 import { H as installContext } from "./chunks/flows-dnIE_qbe.mjs";
-import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-D539mnDI.mjs";
+import { a as verdictWhen, i as verdict, n as runsItsScript, o as whenPrompted, r as testRepo, t as inTurn } from "./chunks/testkit-BUX-47TD.mjs";
 export { inTurn, installContext, runsItsScript, testRepo, verdict, verdictWhen, whenPrompted };

package/dist/web/main.js

@@ -33541,16 +33541,43 @@ const headingTagFor = (depth) => {
 	if (depth === 3) return "h3";
 	return "h4";
 };
+const TickContext = (0, import_react.createContext)(void 0);
+/** A task item's box: tappable when tick wiring exists, else read-only. `picked` is the group's optimistic pick. */
+const TaskBox = ({ item, groupLine, picked }) => {
+	const ticks = (0, import_react.useContext)(TickContext);
+	const on = picked === void 0 ? item.checked === true : item.line === picked;
+	const line = item.line;
+	const tappable = ticks !== void 0 && groupLine !== void 0 && line !== void 0;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", {
+		type: "checkbox",
+		checked: on,
+		readOnly: !tappable,
+		onChange: () => {
+			if (tappable && !on) ticks.onTick(groupLine, line);
+		},
+		className: "mr-2 align-middle"
+	});
+};
+/** A list's pick-one group: its first task item's line, and the optimistic pick there. */
+const useGroupPick = (items) => {
+	const ticks = (0, import_react.useContext)(TickContext);
+	const groupLine = items.find((i) => i.checked !== void 0 && i.line !== void 0)?.line;
+	return {
+		groupLine,
+		picked: groupLine === void 0 ? void 0 : ticks?.pick(groupLine)
+	};
+};
 /** One `list` block's own items, recursively — a nested `items` array renders as a nested `ul`/`ol` inside its parent's `li`. */
 const BlockList = ({ items, ordered }) => {
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ordered ? "ol" : "ul", {
+	const ListTag = ordered ? "ol" : "ul";
+	const { groupLine, picked } = useGroupPick(items);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ListTag, {
 		className: `m-0 list-outside pl-5 ${ordered ? "list-decimal" : "list-disc"}`,
 		children: items.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { children: [
-			item.checked !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", {
-				type: "checkbox",
-				checked: item.checked,
-				readOnly: true,
-				className: "mr-2 align-middle"
+			item.checked !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskBox, {
+				item,
+				groupLine,
+				picked
 			}),
 			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(Inline, {
 				inline: item.inline,
@@ -34021,7 +34048,7 @@ const FreeFormDoneRow = ({ onDone, busy }) => /* @__PURE__ */ (0, import_jsx_run
 		children: "Done"
 	})
 });
-const FreeFormView = ({ view, filePath, isLoading, readError, mode, onSave, onDone, onSaveNote, busy }) => {
+const FreeFormView = ({ view, filePath, isLoading, readError, mode, onSave, onDone, onTick, onSaveNote, busy }) => {
 	const [noteSheetAnchor, setNoteSheetAnchor] = (0, import_react.useState)(void 0);
 	const overlay = useWriteStore((s) => s.overlay);
 	const save = useWriteStore((s) => s.save);
@@ -34052,6 +34079,25 @@ const FreeFormView = ({ view, filePath, isLoading, readError, mode, onSave, onDo
 			write: onSave === void 0 ? void 0 : onSave(APPEND_LINE, text)
 		}).catch(() => {});
 	};
+	const tickWiring = {
+		pick: (groupLine) => {
+			const v = overlay[cellKey(filePath, {
+				kind: "paragraph",
+				line: groupLine
+			}, "tick")]?.value;
+			return typeof v === "number" ? v : void 0;
+		},
+		onTick: (groupLine, line) => {
+			save({
+				cell: cellKey(filePath, {
+					kind: "paragraph",
+					line: groupLine
+				}, "tick"),
+				optimistic: line,
+				write: onTick === void 0 ? void 0 : onTick(line)
+			}).catch(() => {});
+		}
+	};
 	const runDone = () => {
 		if (onDone === void 0) return;
 		save({
@@ -34071,10 +34117,13 @@ const FreeFormView = ({ view, filePath, isLoading, readError, mode, onSave, onDo
 			/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
 				"data-testid": "freeform-scroll",
 				className: "min-h-0 flex-1 overflow-auto",
-				children: view.nodes.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyDocumentCapture, { onSave: saveEmpty }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ProseBlocks, {
-					nodes: view.nodes,
-					noteOverrides,
-					onOpenNote: (n) => setNoteSheetAnchor(n.anchor)
+				children: view.nodes.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EmptyDocumentCapture, { onSave: saveEmpty }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TickContext.Provider, {
+					value: onTick === void 0 ? void 0 : tickWiring,
+					children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ProseBlocks, {
+						nodes: view.nodes,
+						noteOverrides,
+						onOpenNote: (n) => setNoteSheetAnchor(n.anchor)
+					})
 				})
 			}),
 			onDone !== void 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FreeFormDoneRow, {
@@ -34125,6 +34174,22 @@ const useFreeFormMutations = (filePath, mode, onWriteSuccess) => {
 			return result;
 		});
 	};
+	const onTick = (line) => (cas) => {
+		const anchor = {
+			kind: "paragraph",
+			line
+		};
+		return setValue.mutateAsync({
+			filePath,
+			...cas,
+			mode,
+			anchor,
+			checked: true
+		}).then((result) => {
+			onWriteSuccess(result.formatNotice);
+			return result;
+		});
+	};
 	const onSaveNote = (anchor, text) => (cas) => writeNote.mutateAsync({
 		filePath,
 		...cas,
@@ -34138,6 +34203,7 @@ const useFreeFormMutations = (filePath, mode, onWriteSuccess) => {
 	const onDone = () => done.mutateAsync({});
 	return {
 		onSave,
+		onTick,
 		onSaveNote,
 		onDone,
 		isDone: done.isSuccess
@@ -34148,7 +34214,7 @@ const FreeFormInner = ({ filePath, mode, data, isLoading, error }) => {
 	const indicatorProps = useSaveIndicatorProps();
 	const pending = useWriteStore((s) => s.pendingCount);
 	const [formatNotice, setFormatNotice] = (0, import_react.useState)(void 0);
-	const { onSave, onSaveNote, onDone, isDone } = useFreeFormMutations(filePath, mode, setFormatNotice);
+	const { onSave, onTick, onSaveNote, onDone, isDone } = useFreeFormMutations(filePath, mode, setFormatNotice);
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
 		/* @__PURE__ */ (0, import_jsx_runtime.jsx)(SaveIndicator, { ...indicatorProps }),
 		/* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormatNoticeBanner, {
@@ -34163,6 +34229,7 @@ const FreeFormInner = ({ filePath, mode, data, isLoading, error }) => {
 			mode,
 			onSave,
 			onDone,
+			onTick,
 			onSaveNote,
 			busy: pending > 0
 		})
@@ -35882,8 +35949,8 @@ const openable = (step) => step?.status === "ok" && step.file !== void 0;
 * `"qa"` means `Plan`; `"findings"` means `Findings`; anything else (absent, or an unregistered mode name)
 * falls through to `FreeForm`, which reads the file as plain markdown and
 * offers only a note per block, plus a textfield when it's empty. Neither
-* screen offers a way back to a list — `done` is the only
-* thing that ends the turn, and it exits the process.
+* screen offers a way back to a list — `done` hands the turn back (the
+* server keeps running until the outer loop moves on).
 *
 * Never returns `null`: a blank white screen was package 03's own regression
 * (a phone over a tailnet with nothing on-screen to explain why) — every

package/dist/workflow-kit.mjs

@@ -1,5 +1,5 @@
 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-CQzL-lX1.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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmelab/gtd",
-  "version": "64.1.2",
+  "version": "64.3.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

@@ -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,
@@ -547,7 +557,7 @@ Prints a sorted JSON array ([] when clean) and a summary on stderr; --verbose ad
     arity: "none",
     group: "Inspect",
     summary: "Serve the web and phone client",
-    details: `Serve gtd's web and phone client for this worktree. By default it publishes through \`tailscale serve\`, reachable from anywhere on the tailnet, on the first of ports 8443, 10000 and 443 that works; when none does it serves HTTPS locally instead of refusing.`,
+    details: `Serve gtd's web and phone client for this worktree. By default it publishes through \`tailscale serve\`, reachable from anywhere on the tailnet, on the first of ports 8443, 10000 and 443 that works; when none does it serves HTTPS locally instead of refusing. Done saves the steering file and keeps serving; the server exits when the worktree moves on to another step, or on a signal.`,
   },
   {
     token: "guide",
@@ -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,
@@ -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

@@ -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/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/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 {

package/src/steering/freeform.test.ts

@@ -234,7 +234,7 @@ describe("freeFormFormat.annotate", () => {
     const attach = (content: string, text: string): string => {
       const r = freeFormFormat.annotate(content, anchor, text)
       if (!r.ok) throw new Error("refused")
-      return applyEdits(content, r.edits)
+      return applyEditsExact(content, r.edits)
     }
     const created = attach("Paragraph one.\n", "first")
     expect(created).toMatch(/\[\^na\w+\]:\n    - H: first\n/)
@@ -309,3 +309,53 @@ describe("freeFormFormat — thread outline", () => {
     ])
   })
 })
+
+describe("freeFormFormat — task tick", () => {
+  const tick = (content: string, line: number): string => {
+    const r = freeFormFormat.apply(content, { kind: "paragraph", line }, { checked: true })
+    if (!r.ok) throw new Error(r.reason)
+    return applyEditsExact(content, r.edits)
+  }
+
+  it("ticks one box, leaving every other line byte-identical", () => {
+    const doc = "Tick exactly one event:\n\n- [ ] APPROVE\n- [ ] REJECT\n- [ ] CANCEL\n"
+    expect(tick(doc, 2)).toBe(doc.replace("- [ ] APPROVE", "- [x] APPROVE"))
+  })
+
+  it("moves the pick within one list only, leaving nested and other lists alone", () => {
+    const doc = "- [x] a\n  - [x] n1\n  - [ ] n2\n- [ ] b\n\n1. [x] other\n2. [ ] other2\n"
+    expect(tick(doc, 2)).toBe(
+      "- [x] a\n  - [ ] n1\n  - [x] n2\n- [ ] b\n\n1. [x] other\n2. [ ] other2\n",
+    )
+    expect(tick(doc, 3)).toBe(
+      "- [ ] a\n  - [x] n1\n  - [ ] n2\n- [x] b\n\n1. [x] other\n2. [ ] other2\n",
+    )
+  })
+
+  it("ticks a box that sits on the line after a bare marker", () => {
+    const doc = "-\n  [ ] a\n-\n  [x] b\n"
+    expect(tick(doc, 0)).toBe("-\n  [x] a\n-\n  [ ] b\n")
+  })
+
+  it("ticks an ordered item and keeps CRLF; a ticked box is a no-op; a fenced box refuses", () => {
+    expect(tick("1. [ ] a\r\n2. [ ] b\r\n", 1)).toBe("1. [ ] a\r\n2. [x] b\r\n")
+    const done = "- [x] a\n- [ ] b\n"
+    expect(tick(done, 0)).toBe(done)
+    expect(
+      freeFormFormat.apply("```\n- [ ] a\n```\n", { kind: "paragraph", line: 1 }, { checked: true })
+        .ok,
+    ).toBe(false)
+  })
+
+  it("refuses to clear a box, whatever the anchor, and a tick round-trips byte-exact", () => {
+    const doc = "- [x] a\n- [ ] b\n"
+    expect(freeFormFormat.apply(doc, { kind: "paragraph", line: 0 }, { checked: false })).toEqual({
+      ok: false,
+      reason: "pick-never-clears",
+    })
+    const moved = tick(doc, 1)
+    expect(moved).toBe("- [ ] a\n- [x] b\n")
+    const back = freeFormFormat.apply(moved, { kind: "paragraph", line: 0 }, { checked: true })
+    expect(back.ok && applyEditsExact(moved, back.edits)).toBe(doc)
+  })
+})

package/src/steering/freeform.ts

@@ -1,3 +1,4 @@
+import type { ListItem } from "mdast"
 import { blockNodesOf } from "./Blocks.js"
 import { eolOf } from "./Eol.js"
 import {
@@ -93,6 +94,41 @@ const appendEdit = (content: string, text: string): SteeringEdit => {
   return wholeDocumentEdit(content, newText)
 }
 
+/** Every task-list item with its sibling task items (direct children of one list only). */
+const taskGroups = (node: unknown, out: ListItem[][]): void => {
+  const n = node as { type?: string; children?: unknown[] }
+  if (n.type === "list") {
+    out.push((n.children as ListItem[]).filter((i) => i.checked === true || i.checked === false))
+  }
+  for (const c of n.children ?? []) taskGroups(c, out)
+}
+
+/** The box sits on the first child's line, which is not the marker line when a bare `-` precedes it. */
+const boxEdit = (lines: string[], item: ListItem, newText: string): SteeringEdit | undefined => {
+  const line = toLspPosition((item.children[0]?.position ?? item.position!).start).line
+  const m = /\[( |x|X)\]/.exec(lines[line] ?? "")
+  if (!m) return undefined
+  const c = m.index + 1
+  return { range: { start: { line, character: c }, end: { line, character: c + 1 } }, newText }
+}
+
+/** Pick-one tick: sets the box on `line` and unticks its ticked siblings, in one edit set. Ticking an already-ticked box is an empty edit set. */
+const tickEdits = (content: string, line: number): SteeringAnnotateResult => {
+  const lines = content.split("\n")
+  const groups: ListItem[][] = []
+  taskGroups(parseMarkdown(content), groups)
+  const startLine = (i: ListItem): number => toLspPosition(i.position!.start).line
+  const group = groups.find((g) => g.some((i) => startLine(i) === line))
+  if (!group) return { ok: false, reason: "anchor-not-found" }
+  const target = group.find((i) => startLine(i) === line)!
+  if (target.checked === true) return { ok: true, edits: [] }
+  const edits = group
+    .filter((i) => i === target || i.checked === true)
+    .map((i) => boxEdit(lines, i, i === target ? "x" : " "))
+  if (edits.some((e) => e === undefined)) return { ok: false, reason: "anchor-not-found" }
+  return { ok: true, edits: edits as SteeringEdit[] }
+}
+
 /**
  * Free-form's `apply`: only a `paragraph` anchor resolves (the only kind
  * `view` ever reports), and it only ever APPENDS, at or past the document's
@@ -104,6 +140,8 @@ const appendEdit = (content: string, text: string): SteeringEdit => {
  */
 const freeFormApply: SteeringFormat["apply"] = (content, anchor, opts): SteeringAnnotateResult => {
   if (anchor.kind !== "paragraph") return { ok: false, reason: "anchor-not-found" }
+  if (opts.checked === true) return tickEdits(content, anchor.line)
+  if (opts.checked === false) return { ok: false, reason: "pick-never-clears" }
   const text = opts.text ?? ""
   const tree = parseMarkdown(content)
   const lines = content.split(/\r?\n/)

package/src/twins/FakeGitOperations.ts

@@ -77,6 +77,8 @@ const makeGitReaderOps = (repo: InMemRepo, root: string): GitReaderOperations =>
 
   changedPaths: (base?: string) => Effect.succeed(repo.changedPathsWorktree(base)),
 
+  untrackedPaths: () => Effect.succeed(repo.untrackedPaths()),
+
   stagedPaths: () => Effect.succeed(repo.stagedPaths()),
 
   diffPaths: (base: string, tip: string) => tryCatch(() => repo.diffPaths(base, tip)),