@nickmeriano/task 0.8.0 → 0.10.0

package/src/check.test.ts

@@ -27,10 +27,10 @@ test("a board the CLI wrote is clean", () => {
   store.createGoal({ title: "Ship it", description: "the why" })
   const a = store.create({ title: "First", description: "with a body", goal: "ship-it" })
   const b = store.create({ title: "Second", status: "backlog", tags: ["x"] })
-  store.link(b.number, "blocked_by", a.number)
-  store.addComment(a.number, "hello", "claude")
-  store.update(a.number, { status: "done" })
-  store.archive(a.number)
+  store.link(b.key, "blocked_by", a.key)
+  store.addComment(a.key, "hello", "claude")
+  store.update(a.key, { status: "done" })
+  store.archive(a.key)
 
   const result = checkBoards(root, false)
   assert.deepEqual(result.issues, [])
@@ -38,32 +38,70 @@ test("a board the CLI wrote is clean", () => {
   assert.equal(result.files, 4) // two tickets + one comment + one goal
 })
 
+test("ask files are linted like comments; the retired flag reads as an unknown key", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "owed", prefix: "OWE" })
+  const t = store.create({ title: "Owes things", status: "in_progress" })
+  store.addAsk(t.key, "Mint the token", "claude")
+  assert.deepEqual(checkBoards(root, false).issues, [], "a CLI-written ask is clean")
+
+  const asksDir = join(root, ".task", "tickets", t.key, "asks")
+  // Hand-edit shapes: an ask that says nothing, a resolution that isn't a
+  // timestamp, a key nothing reads, and mere drift (unquoted author).
+  writeFileSync(join(asksDir, "z-empty.md"), '---\nauthor: "x"\ncreated: 2026-08-27T00:00:00.000Z\n---\n\n\n')
+  writeFileSync(
+    join(asksDir, "z-bad.md"),
+    '---\nauthor: "x"\ncreated: 2026-08-27T00:00:00.000Z\nresolved: yesterday-ish\nurgency: high\n---\n\nDo the thing\n',
+  )
+  const found = checkBoards(root, false)
+  const messages = found.issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /empty ask/.test(m)), "empty ask reported")
+  assert.ok(messages.some((m) => /resolved is not a valid timestamp/.test(m)), "bad resolution reported")
+  assert.ok(messages.some((m) => /unknown frontmatter key "urgency"/.test(m)), "unknown key reported")
+
+  // The retired pre-0.8 boolean isn't a field anymore — a file still carrying
+  // it (deep history, an ancient branch) reads as an unknown key: flagged,
+  // preserved through rewrites, never interpreted.
+  const ticketPath = join(root, ".task", "tickets", t.key, "ticket.md")
+  writeFileSync(
+    ticketPath,
+    readFileSync(ticketPath, "utf8").replace("status: in_progress", "status: in_progress\nneeds_human: true"),
+  )
+  const flagged = checkBoards(root, true)
+  const unknown = flagged.issues.find((issue) => /unknown frontmatter key "needs_human"/.test(issue.message))
+  assert.ok(unknown, "retired key flagged as unknown")
+  assert.match(readFileSync(ticketPath, "utf8"), /needs_human: true/)
+})
+
 test("finds what merges and hand-edits leave behind, and --fix repairs the mechanical part", () => {
   const root = tempRoot()
   const store = initProject(root, { name: "rough", prefix: "RGH" })
   const a = store.create({ title: "Kept", status: "todo" })
   const b = store.create({ title: "Points at a ghost", status: "todo" })
-  store.create({ title: "Broken later", status: "todo" })
+  const c = store.create({ title: "Broken later", status: "todo" })
 
   // A dangling reference: link b to a ticket, then lose the ticket the way a
   // merge would — the directory vanishes without the store's delete cascade.
-  store.link(b.number, "blocked_by", a.number)
-  const ticketPath = (n: number) => join(root, ".task", "tickets", String(n), "ticket.md")
-  const bText = readFileSync(ticketPath(b.number), "utf8")
-  writeFileSync(ticketPath(b.number), bText.replace("blocked_by: [1]", "blocked_by: [1, 99, 99]"))
+  store.link(b.key, "blocked_by", a.key)
+  const ticketPath = (key: string) => join(root, ".task", "tickets", key, "ticket.md")
+  const bText = readFileSync(ticketPath(b.key), "utf8")
+  writeFileSync(
+    ticketPath(b.key),
+    bText.replace(`blocked_by: ["${a.key}"]`, `blocked_by: ["${a.key}", "zz9zz", "zz9zz"]`),
+  )
 
   // A hand-edit that still parses but isn't canonical (bare goal string).
   store.createGoal({ title: "Launch" })
-  const cText = readFileSync(ticketPath(3), "utf8")
-  writeFileSync(ticketPath(3), cText.replace("status: todo", "status: todo\ngoal: launch"))
+  const cText = readFileSync(ticketPath(c.key), "utf8")
+  writeFileSync(ticketPath(c.key), cText.replace("status: todo", "status: todo\ngoal: launch"))
 
-  // A file that doesn't parse at all.
-  mkdirSync(join(root, ".task", "tickets", "4"))
-  writeFileSync(ticketPath(4), "---\nstatus: todoo\nposition: 0\ncreated: x\nupdated: x\n---\n\n# Bad status\n")
+  // A file that doesn't parse at all, in a well-formed key directory.
+  mkdirSync(join(root, ".task", "tickets", "zzz9x"))
+  writeFileSync(ticketPath("zzz9x"), "---\nstatus: todoo\nposition: 0\ncreated: x\nupdated: x\n---\n\n# Bad status\n")
 
   const found = checkBoards(root, false)
   const messages = found.issues.map((issue) => issue.message)
-  assert.ok(messages.some((m) => /RGH-99, which doesn't exist/.test(m)), "dangling ref reported")
+  assert.ok(messages.some((m) => /RGH-zz9zz, which doesn't exist/.test(m)), "dangling ref reported")
   assert.ok(messages.some((m) => /not in canonical form/.test(m)), "drift reported")
   assert.ok(messages.some((m) => /invalid status "todoo"/.test(m)), "parse error reported")
   assert.ok(messages.some((m) => /not a valid timestamp/.test(m)) === false, "unparseable file isn't double-reported")
@@ -71,8 +109,8 @@ test("finds what merges and hand-edits leave behind, and --fix repairs the mecha
   const fixed = checkBoards(root, true)
   assert.ok(fixed.fixed.length >= 2, "fix rewrote the repairable files")
   // The dangling ref is pruned, the real one kept; the drift is normalized.
-  assert.match(readFileSync(ticketPath(b.number), "utf8"), /blocked_by: \[1\]\n/)
-  assert.match(readFileSync(ticketPath(3), "utf8"), /goal: "launch"/)
+  assert.ok(readFileSync(ticketPath(b.key), "utf8").includes(`blocked_by: ["${a.key}"]\n`))
+  assert.match(readFileSync(ticketPath(c.key), "utf8"), /goal: "launch"/)
 
   // What remains is exactly what needs a human: the unparseable file.
   const after = checkBoards(root, false)
@@ -88,13 +126,13 @@ test("merge artifacts across the archive are reported, never auto-fixed", () =>
   const root = tempRoot()
   const store = initProject(root, { name: "dup", prefix: "DUP" })
   const t = store.create({ title: "Archived on one branch" })
-  store.update(t.number, { status: "done" })
-  store.archive(t.number)
+  store.update(t.key, { status: "done" })
+  store.archive(t.key)
   // The other branch kept editing it — the merge keeps both directories.
-  mkdirSync(join(root, ".task", "tickets", String(t.number)), { recursive: true })
+  mkdirSync(join(root, ".task", "tickets", t.key), { recursive: true })
   writeFileSync(
-    join(root, ".task", "tickets", String(t.number), "ticket.md"),
-    readFileSync(join(root, ".task", "archive", String(t.number), "ticket.md")),
+    join(root, ".task", "tickets", t.key, "ticket.md"),
+    readFileSync(join(root, ".task", "archive", t.key, "ticket.md")),
   )
 
   const result = checkBoards(root, true)
@@ -107,9 +145,9 @@ test("a ticket parked in the archive while still open is flagged", () => {
   const store = initProject(root, { name: "arc", prefix: "ARC" })
   const t = store.create({ title: "Half archived", status: "todo" })
   renameSync(
-    join(root, ".task", "tickets", String(t.number)),
+    join(root, ".task", "tickets", t.key),
     (mkdirSync(join(root, ".task", "archive"), { recursive: true }),
-    join(root, ".task", "archive", String(t.number))),
+    join(root, ".task", "archive", t.key)),
   )
   const result = checkBoards(root, false)
   assert.ok(result.issues.some((issue) => /archived but still todo/.test(issue.message)))
@@ -119,7 +157,7 @@ test("unknown frontmatter keys are reported — and survive a rewrite round-trip
   const root = tempRoot()
   const store = initProject(root, { name: "extra", prefix: "EXT" })
   const t = store.create({ title: "Carries a custom field", status: "todo" })
-  const path = join(root, ".task", "tickets", String(t.number), "ticket.md")
+  const path = join(root, ".task", "tickets", t.key, "ticket.md")
   writeFileSync(
     path,
     readFileSync(path, "utf8").replace("status: todo", 'status: todo\nowner: "nick"'),
@@ -129,7 +167,7 @@ test("unknown frontmatter keys are reported — and survive a rewrite round-trip
   assert.ok(result.issues.some((issue) => /unknown frontmatter key "owner"/.test(issue.message)))
 
   // The sharp edge this fixed: an ordinary update used to drop the key.
-  store.update(t.number, { title: "Renamed" })
+  store.update(t.key, { title: "Renamed" })
   const text = readFileSync(path, "utf8")
   assert.match(text, /owner: "nick"/)
   assert.match(text, /# Renamed/)
@@ -142,30 +180,30 @@ test("unknown frontmatter keys are reported — and survive a rewrite round-trip
   ])
 })
 
-test("the pre-0.8 milestone key is flagged by name, and --fix is the migration", () => {
+test("the pre-0.8 milestone key is refused by name — no migration machinery", () => {
   const root = tempRoot()
   const store = initProject(root, { name: "old", prefix: "OLD" })
   const t = store.create({ title: "From an old board", status: "todo" })
-  const path = join(root, ".task", "tickets", String(t.number), "ticket.md")
+  const path = join(root, ".task", "tickets", t.key, "ticket.md")
   writeFileSync(
     path,
     readFileSync(path, "utf8").replace("status: todo", 'status: todo\nmilestone: "launch"'),
   )
 
-  const found = checkBoards(root, false)
-  const migration = found.issues.find((issue) => /`milestone:` is now `goal:`/.test(issue.message))
-  assert.ok(migration?.fixable, "migration flagged as fixable")
-  // The old key parses as the goal, so the ref lint also fires until the goal
-  // file exists — stated with both ways out, never auto-pruned.
-  assert.ok(
-    found.issues.some((issue) => /goal "launch" doesn't exist/.test(issue.message) && !issue.fixable),
+  // The strict parse refuses the retired spelling with the rename in the
+  // error; check surfaces exactly that, unfixable, and --fix leaves the file
+  // alone — renaming the key is the human's one edit.
+  const found = checkBoards(root, true)
+  const refusal = found.issues.find((issue) =>
+    /`milestone:` is the pre-0\.8 spelling.*rename the key to `goal:`/.test(issue.message),
   )
+  assert.ok(refusal, "retired spelling refused by name")
+  assert.equal(refusal.fixable, false)
+  assert.match(readFileSync(path, "utf8"), /milestone: "launch"/)
 
+  writeFileSync(path, readFileSync(path, "utf8").replace('milestone: "launch"', 'goal: "launch"'))
   store.createGoal({ title: "Launch" })
   checkBoards(root, true)
-  const text = readFileSync(path, "utf8")
-  assert.match(text, /goal: "launch"/)
-  assert.doesNotMatch(text, /milestone/)
   assert.deepEqual(checkBoards(root, false).issues, [])
 })
 
@@ -197,8 +235,8 @@ test("comment files are linted too", () => {
   const root = tempRoot()
   const store = initProject(root, { name: "com", prefix: "COM" })
   const t = store.create({ title: "Talked about" })
-  store.addComment(t.number, "fine", "claude")
-  const dir = join(root, ".task", "tickets", String(t.number), "comments")
+  store.addComment(t.key, "fine", "claude")
+  const dir = join(root, ".task", "tickets", t.key, "comments")
   // A hand-dropped comment: parseable, wrong created, non-canonical spacing.
   writeFileSync(join(dir, "2026-08-15T170000-other.md"), '---\nauthor: "other"\ncreated: not-a-date\n---\nbody\n')
 
@@ -206,7 +244,7 @@ test("comment files are linted too", () => {
   assert.ok(result.issues.some((issue) => /created is not a valid timestamp/.test(issue.message)))
 })
 
-test("config lints: legacy claimPrefix migrates, boards is root-only, prefixes must agree", () => {
+test("config lints: retired claimPrefix refuses, boards is root-only, prefixes must agree", () => {
   const root = tempRoot()
   initProject(root, { name: "cfg", prefix: "CFG" })
   const rootConfig = join(root, ".task", "config.json")
@@ -225,33 +263,21 @@ test("config lints: legacy claimPrefix migrates, boards is root-only, prefixes m
   subRaw.claims = { branchPrefix: "task/claim/" }
   writeFileSync(subConfig, `${JSON.stringify(subRaw, null, 2)}\n`)
 
-  const found = checkBoards(root, false)
+  // The retired key with no claims.branchPrefix beside it: claimNamespace
+  // refuses by name, check surfaces that refusal, and --fix touches nothing —
+  // renaming the key is the human's one edit. The root's namespace being
+  // unreadable also means the sub-board mismatch lint has no reference to
+  // compare against; the root-only boards lint still fires.
+  const found = checkBoards(root, true)
   const messages = found.issues.map((issue) => issue.message)
-  assert.ok(messages.some((m) => /`claimPrefix` is now `claims\.branchPrefix`/.test(m)))
+  assert.ok(messages.some((m) => /`claimPrefix` in \.task\/config\.json is the pre-0\.8 spelling/.test(m)))
   assert.ok(messages.some((m) => /"boards" is root-only/.test(m)))
-  assert.ok(messages.some((m) => /disagrees with the root board's "claude\/task\/"/.test(m)))
-
-  // --fix migrates the legacy key in place; the human decisions remain.
-  const fixed = checkBoards(root, true)
-  assert.ok(fixed.fixed.includes(".task/config.json"))
-  const migrated = JSON.parse(readFileSync(rootConfig, "utf8")) as {
-    claimPrefix?: string
-    claims?: { branchPrefix?: string }
-    boards?: string[]
-    prefix: string
-  }
-  assert.equal(migrated.claimPrefix, undefined)
-  assert.equal(migrated.claims?.branchPrefix, "claude/task/")
-  assert.deepEqual(migrated.boards, ["CFG", "SUB"])
-  assert.equal(migrated.prefix, "CFG")
-
-  const remaining = checkBoards(root, false).issues.map((issue) => issue.message)
-  assert.ok(!remaining.some((m) => /`claimPrefix` is now/.test(m)), "nag gone after migration")
-  assert.ok(remaining.some((m) => /"boards" is root-only/.test(m)), "root-only lint stays")
-  assert.ok(remaining.some((m) => /disagrees with the root board's/.test(m)), "mismatch stays")
+  assert.ok(found.issues.every((issue) => !issue.fixable || !/claimPrefix/.test(issue.message)))
+  const untouched = JSON.parse(readFileSync(rootConfig, "utf8")) as { claimPrefix?: string }
+  assert.equal(untouched.claimPrefix, "claude/task/")
 })
 
-test("an existing claims.branchPrefix wins over the legacy key on migration", () => {
+test("a stray claimPrefix beside claims.branchPrefix is inert and flagged", () => {
   const root = tempRoot()
   initProject(root, { name: "dup", prefix: "DUP" })
   const configPath = join(root, ".task", "config.json")
@@ -260,12 +286,43 @@ test("an existing claims.branchPrefix wins over the legacy key on migration", ()
   raw.claims = { branchPrefix: "new/ns/", maxOpenCount: 2 }
   writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`)
 
-  checkBoards(root, true)
-  const migrated = JSON.parse(readFileSync(configPath, "utf8")) as {
-    claimPrefix?: string
-    claims?: { branchPrefix?: string; maxOpenCount?: number }
-  }
-  assert.equal(migrated.claimPrefix, undefined)
-  assert.equal(migrated.claims?.branchPrefix, "new/ns/")
-  assert.equal(migrated.claims?.maxOpenCount, 2)
+  const messages = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(messages.some((m) => /`claims\.branchPrefix` wins; delete the leftover key/.test(m)))
+})
+
+test("numeric ticket dirs are called out as pre-TAS-42 — junk entries separately", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "mig", prefix: "MIG" })
+  store.create({ title: "A modern ticket", status: "todo" })
+
+  // A pre-migration ticket, imported by merging a branch cut before the id
+  // cutover: numeric directory, numeric blocked_by.
+  mkdirSync(join(root, ".task", "tickets", "42"), { recursive: true })
+  writeFileSync(
+    join(root, ".task", "tickets", "42", "ticket.md"),
+    "---\nstatus: todo\nposition: 0\ncreated: 2026-08-15T16:00:33.758Z\nupdated: 2026-08-15T16:00:33.758Z\n---\n\n# Old-format ticket\n",
+  )
+  // And something that was never a ticket directory at all.
+  mkdirSync(join(root, ".task", "tickets", "Not A Key"), { recursive: true })
+
+  const messages = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(
+    messages.some((m) => /numeric ticket directory — the pre-TAS-42 sequential-id format/.test(m)),
+    "pre-migration dir named with the migration fix",
+  )
+  assert.ok(
+    messages.some((m) => /ticket directories are named by their key/.test(m)),
+    "junk entry reported as unexpected",
+  )
+
+  // A modern file whose blocked_by still carries numbers is refused by the
+  // strict parser with the migration named — surfaced through check.
+  const modern = store.create({ title: "Bad link format", status: "todo" })
+  const path = join(root, ".task", "tickets", modern.key, "ticket.md")
+  writeFileSync(
+    path,
+    readFileSync(path, "utf8").replace("status: todo", "status: todo\nblocked_by: [7]"),
+  )
+  const after = checkBoards(root, false).issues.map((issue) => issue.message)
+  assert.ok(after.some((m) => /pre-TAS-42 id format, which is no longer read/.test(m)))
 })

package/src/check.ts

@@ -10,8 +10,9 @@
  * references (one branch deleted a ticket another branch linked to), `goal:`
  * refs naming a goal that doesn't exist, tickets duplicated between the board
  * and the archive, unknown frontmatter keys, and formatting drift from the
- * canonical serialization (including the pre-0.8 `milestone:` key, whose
- * rewrite to `goal:` is the migration).
+ * canonical serialization. Retired pre-0.8 spellings (`milestone:`,
+ * `claimPrefix`) are refused by the parsers with the rename in the error —
+ * this lint just surfaces those messages; there is no migration machinery.
  *
  * The mechanical repairs — pruning dangling or self references, deduping and
  * sorting `blocked_by`, rewriting a file into canonical form — are applied by
@@ -24,6 +25,7 @@ import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import {
   ARCHIVE_DIR,
+  ASKS_DIR,
   COMMENTS_DIR,
   GOALS_ARCHIVE_DIR,
   GOALS_DIR,
@@ -31,13 +33,16 @@ import {
   TICKET_FILE,
 } from "./file-store.ts"
 import {
+  ASK_FIELDS,
   COMMENT_FIELDS,
   TicketParseError,
   frontmatterKeys,
   isGoalSlug,
+  parseAsk,
   parseComment,
   parseGoal,
   parseTicket,
+  serializeAsk,
   serializeComment,
   serializeGoal,
   serializeTicket,
@@ -53,6 +58,7 @@ import {
   type BoardRef,
 } from "./store.ts"
 import { claimNamespace } from "./claim.ts"
+import { isTicketKey } from "./id.ts"
 import type { ProjectConfig } from "./types.ts"
 
 export interface CheckIssue {
@@ -80,7 +86,7 @@ export function checkRoot(cwd: string): string {
 }
 
 interface TicketEntry {
-  number: number
+  key: string
   /** Path relative to the check root, for reporting. */
   file: string
   /** Absolute path, for fixing. */
@@ -131,20 +137,20 @@ export function checkBoards(root: string, fix: boolean): CheckResult {
 }
 
 /**
- * Config lints (TAS-27): the pre-0.8 `claimPrefix` spelling (fixable — the
- * migration to `claims.branchPrefix` is mechanical), a `boards` list on a
- * non-root board (root-only by design, so vendored boards can't opt into a
- * repo's automation), a malformed one, an unusable branch prefix, and a
- * branch prefix that disagrees with the root board's (workflows match claim
- * branches by pattern — one repo, one namespace).
+ * Config lints (TAS-27): a `boards` list on a non-root board (root-only by
+ * design, so vendored boards can't opt into a repo's automation), a malformed
+ * one, an unusable branch prefix, a branch prefix that disagrees with the
+ * root board's (workflows match claim branches by pattern — one repo, one
+ * namespace), and a leftover pre-0.8 `claimPrefix` key. The retired spelling
+ * is not migrated anymore (TAS-41: no compat) — with no `claims.branchPrefix`
+ * beside it, `claimNamespace` refuses by name and that error surfaces here;
+ * with one, the stray key is inert and gets its own line.
  */
 function checkConfig(
   board: BoardRef,
   scopeRoot: string,
   rootBranchPrefix: string | null,
-  fix: boolean,
   push: (file: string, message: string, fixable?: boolean) => void,
-  fixed: string[],
 ): ProjectConfig | null {
   const absolute = join(board.root, TASK_DIR, CONFIG_FILE)
   const file = posixJoin(board.id, TASK_DIR, CONFIG_FILE)
@@ -157,28 +163,11 @@ function checkConfig(
   }
   const config = raw as unknown as ProjectConfig
 
-  if (raw.claimPrefix !== undefined) {
-    push(file, "`claimPrefix` is now `claims.branchPrefix` — `task check --fix` rewrites it", true)
-    if (fix) {
-      // In-place key replacement so the migration diff is one line where
-      // possible; an existing claims.branchPrefix wins over the legacy key.
-      const claims = {
-        ...(typeof raw.claims === "object" && raw.claims !== null
-          ? (raw.claims as Record<string, unknown>)
-          : {}),
-      }
-      claims.branchPrefix ??= raw.claimPrefix
-      const migrated: Record<string, unknown> = {}
-      for (const [key, value] of Object.entries(raw)) {
-        if (key === "claimPrefix") {
-          if (raw.claims === undefined) migrated.claims = claims
-          continue
-        }
-        migrated[key] = key === "claims" ? claims : value
-      }
-      writeFileSync(absolute, `${JSON.stringify(migrated, null, 2)}\n`)
-      fixed.push(file)
-    }
+  if (raw.claimPrefix !== undefined && config.claims?.branchPrefix !== undefined) {
+    push(
+      file,
+      "`claimPrefix` is the pre-0.8 spelling and is no longer read — `claims.branchPrefix` wins; delete the leftover key",
+    )
   }
 
   if (raw.boards !== undefined) {
@@ -230,9 +219,9 @@ function checkBoard(
   const push = (file: string, message: string, fixable = false) =>
     issues.push({ board: board.id, file, message, fixable })
 
-  const config = checkConfig(board, scopeRoot, rootBranchPrefix, fix, push, fixed)
+  const config = checkConfig(board, scopeRoot, rootBranchPrefix, push)
   const prefix = config?.prefix ?? "TASK"
-  const displayId = (n: number) => `${prefix}-${n}`
+  const displayId = (k: string) => `${prefix}-${k}`
 
   // ── Collect every ticket, live and archived ────────────────────────────────
   const tickets: TicketEntry[] = []
@@ -246,8 +235,21 @@ function checkBoard(
     for (const entry of readdirSync(home, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) continue
       const relEntry = posixJoin(relTaskDir, dir, entry.name)
-      if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) {
-        push(relEntry, "unexpected entry — the board only reads numeric ticket directories")
+      // A purely numeric directory is a pre-TAS-42 ticket — the old
+      // sequential-id format, which nothing reads anymore. The likely way one
+      // appears post-migration is merging a branch cut before the cutover;
+      // the fix is mechanical and named here.
+      if (entry.isDirectory() && /^\d+$/.test(entry.name)) {
+        push(
+          relEntry,
+          "numeric ticket directory — the pre-TAS-42 sequential-id format, which is no longer read; migrate it with `node tools/migrate-ids/migrate.mjs --ticket <board-dir> " +
+            entry.name +
+            "`",
+        )
+        continue
+      }
+      if (!entry.isDirectory() || !isTicketKey(entry.name)) {
+        push(relEntry, "unexpected entry — ticket directories are named by their key (e.g. x7k4m)")
         continue
       }
       const absolute = join(home, entry.name, TICKET_FILE)
@@ -265,20 +267,22 @@ function checkBoard(
         if (!(error instanceof TicketParseError)) throw error
         push(file, reason(error, file))
       }
-      tickets.push({ number: Number(entry.name), file, absolute, archived, text, doc })
+      tickets.push({ key: entry.name, file, absolute, archived, text, doc })
     }
   }
 
   // A ticket present in both tickets/ and archive/ is a merge artifact: one
   // branch archived it while another kept editing it. Which copy wins is a
-  // human call, so it's reported, never auto-fixed.
-  const live = new Set(tickets.filter((t) => !t.archived).map((t) => t.number))
-  const valid = new Set(tickets.map((t) => t.number))
+  // human call, so it's reported, never auto-fixed. (This doubles as the
+  // duplicate-key lint: within either directory git itself makes duplicates
+  // impossible, so board-and-archive is the only place one can exist.)
+  const live = new Set(tickets.filter((t) => !t.archived).map((t) => t.key))
+  const valid = new Set(tickets.map((t) => t.key))
   for (const ticket of tickets) {
-    if (ticket.archived && live.has(ticket.number)) {
+    if (ticket.archived && live.has(ticket.key)) {
       push(
         ticket.file,
-        `${displayId(ticket.number)} also exists in ${TICKETS_DIR}/ — a merge kept both copies; delete one`,
+        `${displayId(ticket.key)} also exists in ${TICKETS_DIR}/ — a merge kept both copies; delete one`,
       )
     }
   }
@@ -344,7 +348,7 @@ function checkBoard(
 
   // ── Per-ticket content checks ──────────────────────────────────────────────
   for (const ticket of tickets) {
-    const { doc, file, number } = ticket
+    const { doc, file, key } = ticket
     if (!doc) continue
 
     for (const [key, at] of [
@@ -377,13 +381,13 @@ function checkBoard(
     // The repaired relation list: no self references, no dangling targets, no
     // duplicates, sorted. Each divergence is its own issue; all are mechanical.
     const pruned = [...new Set(doc.blockedBy)]
-      .filter((n) => n !== number && valid.has(n))
-      .sort((a, b) => a - b)
-    if (doc.blockedBy.includes(number)) {
-      push(file, `${displayId(number)} is blocked by itself`, true)
+      .filter((k) => k !== key && valid.has(k))
+      .sort((a, b) => a.localeCompare(b))
+    if (doc.blockedBy.includes(key)) {
+      push(file, `${displayId(key)} is blocked by itself`, true)
     }
     for (const target of new Set(doc.blockedBy)) {
-      if (target !== number && !valid.has(target)) {
+      if (target !== key && !valid.has(target)) {
         push(file, `blocked_by references ${displayId(target)}, which doesn't exist`, true)
       }
     }
@@ -391,18 +395,14 @@ function checkBoard(
     // Everything else — duplicate or unsorted blocked_by, hand-edited field
     // order or quoting, stray whitespace — is formatting drift: the parse is
     // fine, the bytes just aren't what the CLI would write. `normalized` keeps
-    // the dangling refs so drift isn't double-reported on top of them.
-    //
-    // One drift gets its own words: a pre-0.8 `milestone:` key. It already
-    // parses as the goal, and the canonical rewrite is the whole migration —
-    // but "not in canonical form" would undersell what the fix is about to do.
+    // the dangling refs so drift isn't double-reported on top of them. (The
+    // pre-0.8 `milestone:` key never reaches here — the strict parse refuses
+    // it by name, and that error is the whole report.)
     const normalized = serializeTicket({
       ...doc,
-      blockedBy: [...new Set(doc.blockedBy)].sort((a, b) => a - b),
+      blockedBy: [...new Set(doc.blockedBy)].sort((a, b) => a.localeCompare(b)),
     })
-    if (frontmatterKeys(ticket.text)?.includes("milestone")) {
-      push(file, "`milestone:` is now `goal:` — `task check --fix` rewrites it", true)
-    } else if (normalized !== ticket.text) {
+    if (normalized !== ticket.text) {
       push(file, "not in canonical form — `task check --fix` rewrites it", true)
     }
     const canonical = serializeTicket({ ...doc, blockedBy: pruned })
@@ -412,6 +412,49 @@ function checkBoard(
     }
   }
 
+  // ── Asks ───────────────────────────────────────────────────────────────────
+  // Same pass as comments: strict parse, timestamps, unknown keys, canonical
+  // drift. An empty ask body gets its own line — an ask that doesn't say what's
+  // owed is the old boolean wearing a new file.
+  const knownAskKeys = new Set<string>(ASK_FIELDS)
+  for (const ticket of tickets) {
+    const dir = join(ticket.absolute, "..", ASKS_DIR)
+    if (!existsSync(dir)) continue
+    for (const entry of readdirSync(dir)) {
+      if (!entry.endsWith(".md") || entry.startsWith(".")) continue
+      files++
+      const file = posixJoin(ticket.file.slice(0, -TICKET_FILE.length - 1), ASKS_DIR, entry)
+      const text = readFileSync(join(dir, entry), "utf8")
+      let parsed
+      try {
+        parsed = parseAsk(text, file)
+      } catch (error) {
+        if (!(error instanceof TicketParseError)) throw error
+        push(file, reason(error, file))
+        continue
+      }
+      if (!isValidTimestamp(parsed.createdAt)) push(file, "created is not a valid timestamp")
+      if (parsed.resolvedAt !== null && !isValidTimestamp(parsed.resolvedAt)) {
+        push(file, "resolved is not a valid timestamp")
+      }
+      if (!parsed.body.trim()) push(file, "empty ask — say what a person owes, or delete it")
+      let unknownKeys = false
+      for (const key of frontmatterKeys(text) ?? []) {
+        if (knownAskKeys.has(key)) continue
+        unknownKeys = true
+        push(file, `unknown frontmatter key "${key}"`)
+      }
+      const canonical = serializeAsk(parsed)
+      if (canonical !== text && !unknownKeys) {
+        push(file, "not in canonical form — `task check --fix` rewrites it", true)
+        if (fix) {
+          writeFileSync(join(dir, entry), canonical)
+          fixed.push(file)
+        }
+      }
+    }
+  }
+
   // ── Comments ───────────────────────────────────────────────────────────────
   const knownCommentKeys = new Set<string>(COMMENT_FIELDS)
   for (const ticket of tickets) {