@nickmeriano/task 0.7.1 → 0.9.0

package/src/store.test.ts

@@ -4,8 +4,7 @@
  * 1. The text format round-trips — parse(serialize(x)) loses nothing.
  * 2. `FileStore` behaves like the store always has (positions, links,
  *    comments, cascade on delete).
- * 3. `task migrate` reproduces a legacy SQLite board in files, exactly.
- * 4. Concurrent-writer shapes merge by construction: a comment is a new file,
+ * 3. Concurrent-writer shapes merge by construction: a comment is a new file,
  *    a claim is a one-line status diff.
  */
 
@@ -14,9 +13,10 @@ import { test } from "node:test"
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
-import { FileStore, initProject, migrateBoard, openBoard } from "./file-store.ts"
-import { parseTicket, serializeTicket, type TicketDoc } from "./ticket-doc.ts"
-import { TaskStore, findBoardsByPrefix, findScopeRoot } from "./store.ts"
+import { FileStore, initProject, openBoard } from "./file-store.ts"
+import { KEY_PATTERN } from "./id.ts"
+import { parseTicket, parseTicketLenient, serializeTicket, type TicketDoc } from "./ticket-doc.ts"
+import { findBoardsByPrefix, findScopeRoot } from "./store.ts"
 
 function tempRoot(): string {
   const dir = mkdtempSync(join(tmpdir(), "task-test-"))
@@ -31,8 +31,7 @@ test("ticket documents round-trip, including the awkward bodies", () => {
       description: "One line.",
       status: "todo",
       tags: [],
-      milestone: null,
-      needsHuman: false,
+      goal: null,
       blockedBy: [],
       prs: [],
       position: 1024,
@@ -46,9 +45,8 @@ test("ticket documents round-trip, including the awkward bodies", () => {
       description: "# Not the title\n\n---\n\nstatus: not-a-field\n\n```md\n---\n```",
       status: "in_progress",
       tags: ["storage", "architecture"],
-      milestone: "v2 storage",
-      needsHuman: true,
-      blockedBy: [3, 7],
+      goal: "v2-storage",
+      blockedBy: ["k3mfp", "x7c2d"],
       prs: ["https://github.com/x/y/pull/1"],
       position: -512.5,
       createdAt: "2026-08-15T16:00:33.758Z",
@@ -59,8 +57,7 @@ test("ticket documents round-trip, including the awkward bodies", () => {
       description: "",
       status: "backlog",
       tags: [],
-      milestone: null,
-      needsHuman: false,
+      goal: null,
       blockedBy: [],
       prs: [],
       position: 0,
@@ -77,7 +74,7 @@ test("hand-edits are forgiven where they're unambiguous", () => {
   const text = [
     "---",
     "status: todo",
-    "milestone: launch", // unquoted string — the YAML instinct
+    "goal: launch", // unquoted string — the YAML instinct
     "position: 8",
     "created: 2026-08-15T16:00:33.758Z",
     "updated: 2026-08-15T16:00:33.758Z",
@@ -88,9 +85,19 @@ test("hand-edits are forgiven where they're unambiguous", () => {
     "Body.",
   ].join("\n")
   const doc = parseTicket(text, "test")
-  assert.equal(doc.milestone, "launch")
+  assert.equal(doc.goal, "launch")
   assert.equal(doc.position, 8)
 
+  // The pre-0.8 `milestone:` spelling is refused by name (TAS-41: no compat)
+  // — reading past it would silently drop the goal, so the error carries the
+  // one edit that fixes the file. The lenient parser just ignores it.
+  assert.throws(
+    () => parseTicket(text.replace("goal: launch", "milestone: launch"), "test"),
+    /`milestone:` is the pre-0\.8 spelling.*rename the key to `goal:`/,
+  )
+  const degraded = parseTicketLenient(text.replace("goal: launch", "milestone: launch"))
+  assert.equal(degraded?.goal, null)
+
   assert.throws(
     () => parseTicket(text.replace("status: todo", "status: todoo"), "here"),
     /here.*invalid status/,
@@ -104,158 +111,201 @@ test("FileStore keeps the store's contract", () => {
   assert.equal(store.config.prefix, "SAM")
   assert.ok(store instanceof FileStore)
 
-  const a = store.create({ title: "First", description: "alpha", tags: ["api"] })
+  const a = store.create({ title: "First", description: "alpha", tags: ["api"], status: "todo" })
   const b = store.create({ title: "Second", status: "todo" })
   const c = store.create({ title: "Third", status: "backlog" })
-  assert.deepEqual([a.number, b.number, c.number], [1, 2, 3])
+  // Keys are random, well-formed, and distinct — never sequential (TAS-42).
+  for (const t of [a, b, c]) assert.match(t.key, KEY_PATTERN)
+  assert.equal(new Set([a.key, b.key, c.key]).size, 3)
+  assert.equal(a.id, `SAM-${a.key}`)
   // New tasks land at the bottom of their column.
   assert.ok(b.position > a.position)
 
   // Status move without an explicit slot lands on top of the new column.
-  const moved = store.update(c.number, { status: "todo" })
+  const moved = store.update(c.key, { status: "todo" })
   assert.ok(moved.position < a.position)
-  assert.equal(store.list({ statuses: ["todo"] })[0].number, c.number)
+  assert.equal(store.list({ statuses: ["todo"] })[0].key, c.key)
 
   // One relation, two views, stored on one side only.
-  store.link(a.number, "blocked_by", b.number)
-  assert.deepEqual(store.get(b.number)!.blocks, [a.number])
-  const onDisk = readFileSync(join(root, ".task", "tickets", "1", "ticket.md"), "utf8")
-  assert.match(onDisk, /blocked_by: \[2\]/)
+  store.link(a.key, "blocked_by", b.key)
+  assert.deepEqual(store.get(b.key)!.blocks, [a.key])
+  const onDisk = readFileSync(join(root, ".task", "tickets", a.key, "ticket.md"), "utf8")
+  assert.ok(onDisk.includes(`blocked_by: ["${b.key}"]`))
   assert.doesNotMatch(
-    readFileSync(join(root, ".task", "tickets", "2", "ticket.md"), "utf8"),
+    readFileSync(join(root, ".task", "tickets", b.key, "ticket.md"), "utf8"),
     /blocked_by/,
   )
-  store.unlink(b.number, "blocks", a.number)
-  assert.deepEqual(store.get(a.number)!.blockedBy, [])
+  store.unlink(b.key, "blocks", a.key)
+  assert.deepEqual(store.get(a.key)!.blockedBy, [])
 
-  assert.throws(() => store.link(a.number, "blocks", a.number), /can't block itself/)
-  assert.throws(() => store.update(a.number, { blockedBy: [99] }), /no such task: SAM-99/)
+  assert.throws(() => store.link(a.key, "blocks", a.key), /can't block itself/)
+  assert.throws(() => store.update(a.key, { blockedBy: ["zz9zz"] }), /no such task: SAM-zz9zz/)
+
+  // parseId: exact keys, PREFIX-key, and unique git-style prefixes all land.
+  assert.equal(store.parseId(a.key), a.key)
+  assert.equal(store.parseId(`SAM-${a.key}`), a.key)
+  assert.equal(store.parseId(a.key.toUpperCase()), a.key)
+  const uniquePrefix = [a, b, c].every((t) => t.key[0] !== a.key[0] || t.key === a.key)
+    ? a.key[0]
+    : a.key.slice(0, 4)
+  if ([a, b, c].filter((t) => t.key.startsWith(uniquePrefix)).length === 1) {
+    assert.equal(store.parseId(uniquePrefix), a.key)
+  }
+  assert.throws(() => store.parseId("not an id!"), /invalid task id/)
 
   // Comments: one file each, stable ids, author preserved.
-  const comment = store.addComment(a.number, "first!\n\nwith **markdown**", "claude")
+  const comment = store.addComment(a.key, "first!\n\nwith **markdown**", "claude")
   assert.match(comment.id, /^\d{4}-\d{2}-\d{2}T\d{6}-claude$/)
-  assert.equal(store.comments(a.number)[0].body, "first!\n\nwith **markdown**")
-  assert.equal(store.commentCounts().get(a.number), 1)
-  const second = store.addComment(a.number, "again", "claude")
+  assert.equal(store.comments(a.key)[0].body, "first!\n\nwith **markdown**")
+  assert.equal(store.commentCounts().get(a.key), 1)
+  const second = store.addComment(a.key, "again", "claude")
   assert.notEqual(second.id, comment.id)
-  store.deleteComment(a.number, second.id)
-  assert.equal(store.comments(a.number).length, 1)
-  assert.throws(() => store.deleteComment(a.number, "../../escape"), /no such comment/)
+  store.deleteComment(a.key, second.id)
+  assert.equal(store.comments(a.key).length, 1)
+  assert.throws(() => store.deleteComment(a.key, "../../escape"), /no such comment/)
 
   // Delete cascades the relation away, like the FK did.
-  store.link(b.number, "blocked_by", a.number)
-  store.delete(a.number)
-  assert.equal(store.get(a.number), null)
-  assert.deepEqual(store.get(b.number)!.blockedBy, [])
-
-  // Numbers never move backwards past an existing ticket.
-  const d = store.create({ title: "Fourth" })
-  assert.equal(d.number, 4)
+  store.link(b.key, "blocked_by", a.key)
+  store.delete(a.key)
+  assert.equal(store.get(a.key), null)
+  assert.deepEqual(store.get(b.key)!.blockedBy, [])
 })
 
-test("openBoard picks the backend by what's on disk", () => {
+test("openBoard reads text boards, and refuses a pre-0.6 SQLite board loudly", () => {
   const fileRoot = tempRoot()
   initProject(fileRoot, { name: "files" })
   assert.ok(openBoard(fileRoot) instanceof FileStore)
 
+  // A pre-0.6 board: version-1 config, committed database, no tickets/ tree.
+  // Reading it as an empty text board would silently strand every ticket in
+  // the database, so it must refuse instead — pointing at the last release
+  // that still carries `task migrate`.
   const legacyRoot = tempRoot()
   mkdirSync(join(legacyRoot, ".task"))
   writeFileSync(
     join(legacyRoot, ".task", "config.json"),
     `${JSON.stringify({ name: "legacy", prefix: "LEG", version: 1 }, null, 2)}\n`,
   )
-  const legacy = openBoard(legacyRoot)
-  assert.ok(legacy instanceof TaskStore)
-  legacy.close()
-})
+  writeFileSync(join(legacyRoot, ".task", "tasks.db"), "not really a database")
+  assert.throws(() => openBoard(legacyRoot), /pre-0\.6 SQLite database.*migrate/)
 
-test("migrate reproduces a legacy board, byte-visible and loss-free", () => {
-  const root = tempRoot()
-  mkdirSync(join(root, ".task"))
+  // A version-2 board with no tickets yet is just an empty board, not legacy.
+  const emptyRoot = tempRoot()
+  mkdirSync(join(emptyRoot, ".task"))
   writeFileSync(
-    join(root, ".task", "config.json"),
-    `${JSON.stringify({ name: "legacy board", prefix: "LEG", version: 1 }, null, 2)}\n`,
-  )
-  const legacy = new TaskStore(root)
-  const one = legacy.create({ title: "Keep me", description: "with *body*", tags: ["a", "b"] })
-  const two = legacy.create({
-    title: "Blocked one",
-    status: "in_progress",
-    milestone: "launch",
-    needsHuman: true,
-    blockedBy: [one.number],
-    prs: ["https://github.com/x/y/pull/9"],
-  })
-  legacy.addComment(one.number, "hello", "nick")
-  legacy.addComment(one.number, "and back", "claude")
-  const expectedTasks = legacy.list({})
-  const expectedComments = legacy.comments(one.number)
-  legacy.close()
-
-  const result = migrateBoard(root)
-  assert.deepEqual(result, { tasks: 2, comments: 2 })
-  assert.throws(() => migrateBoard(root), /already migrated/)
-
-  const store = openBoard(root)
-  assert.ok(store instanceof FileStore)
-  assert.deepEqual(store.list({}), expectedTasks)
-  assert.deepEqual(
-    store.comments(one.number).map(({ author, body, createdAt }) => ({ author, body, createdAt })),
-    expectedComments.map(({ author, body, createdAt }) => ({ author, body, createdAt })),
-  )
-  assert.deepEqual(store.get(two.number)!.blockedBy, [one.number])
-  assert.match(readFileSync(join(root, ".task", ".gitignore"), "utf8"), /tasks\.db/)
-  assert.equal(
-    (JSON.parse(readFileSync(join(root, ".task", "config.json"), "utf8")) as { version: number })
-      .version,
-    2,
+    join(emptyRoot, ".task", "config.json"),
+    `${JSON.stringify({ name: "empty", prefix: "EMP", version: 2 }, null, 2)}\n`,
   )
+  assert.deepEqual(openBoard(emptyRoot).list({}), [])
 })
 
 test("archive moves finished tickets off the hot path, losing nothing", () => {
   const root = tempRoot()
   const store = initProject(root, { name: "archive test", prefix: "ARC" })
-  const keep = store.create({ title: "Still open" })
-  const old = store.create({ title: "Finished work" })
-  store.link(keep.number, "blocked_by", old.number)
-  store.addComment(old.number, "how it went", "nick")
+  const keep = store.create({ title: "Still open", status: "todo" })
+  const old = store.create({ title: "Finished work", status: "todo" })
+  store.link(keep.key, "blocked_by", old.key)
+  store.addComment(old.key, "how it went", "nick")
 
   // Only finished work qualifies — archive is history, not a hiding place.
-  assert.throws(() => store.archive(old.number), /is todo/)
-  store.update(old.number, { status: "done" })
-  const archived = store.archive(old.number)
+  assert.throws(() => store.archive(old.key), /is todo/)
+  store.update(old.key, { status: "done" })
+  const archived = store.archive(old.key)
   assert.equal(archived.archived, true)
 
   // Off the board and out of every default read…
-  assert.deepEqual(store.list({}).map((t) => t.number), [keep.number])
-  assert.equal(store.commentCounts().get(old.number), undefined)
+  assert.deepEqual(store.list({}).map((t) => t.key), [keep.key])
+  assert.equal(store.commentCounts().get(old.key), undefined)
   // …but reads still reach it, comments included, and its links still show.
-  const shown = store.get(old.number)!
+  const shown = store.get(old.key)!
   assert.equal(shown.archived, true)
-  assert.deepEqual(shown.blocks, [keep.number])
-  assert.equal(store.comments(old.number)[0].body, "how it went")
+  assert.deepEqual(shown.blocks, [keep.key])
+  assert.equal(store.comments(old.key)[0].body, "how it went")
   const listed = store.list({ archived: true })
-  assert.deepEqual(listed.map((t) => [t.number, t.archived]), [[old.number, true]])
+  assert.deepEqual(listed.map((t) => [t.key, t.archived]), [[old.key, true]])
 
   // Writes refuse until unarchived, with a message that says what to do.
-  assert.throws(() => store.update(old.number, { title: "x" }), /archived — run/)
-  assert.throws(() => store.addComment(old.number, "x", "y"), /archived — run/)
-  assert.throws(() => store.delete(old.number), /archived — run/)
-  assert.throws(() => store.archive(old.number), /already archived/)
+  assert.throws(() => store.update(old.key, { title: "x" }), /archived — run/)
+  assert.throws(() => store.addComment(old.key, "x", "y"), /archived — run/)
+  assert.throws(() => store.delete(old.key), /archived — run/)
+  assert.throws(() => store.archive(old.key), /already archived/)
   // Linking *to* an archived target refuses; pruning a stale link succeeds.
-  assert.throws(() => store.link(keep.number, "blocked_by", old.number), /archived — run/)
-  assert.deepEqual(store.update(keep.number, { blockedBy: [] }).blockedBy, [])
+  assert.throws(() => store.link(keep.key, "blocked_by", old.key), /archived — run/)
+  assert.deepEqual(store.update(keep.key, { blockedBy: [] }).blockedBy, [])
 
-  // Numbers stay reserved — the next ticket never reuses an archived one.
-  assert.equal(store.create({ title: "Next" }).number, 3)
+  // Keys stay reserved — a new mint can never take an archived ticket's name.
+  const next = store.create({ title: "Next" })
+  assert.notEqual(next.key, old.key)
+  // An archived key still resolves through parseId (exact match).
+  assert.equal(store.parseId(`ARC-${old.key}`), old.key)
 
   // Round trip: unarchive puts it back exactly as it was.
-  const back = store.unarchive(old.number)
+  const back = store.unarchive(old.key)
   assert.equal(back.archived, undefined)
   assert.equal(back.status, "done")
   assert.deepEqual(store.list({ archived: true }), [])
-  assert.equal(store.comments(old.number).length, 1)
-  assert.throws(() => store.unarchive(old.number), /isn't archived/)
+  assert.equal(store.comments(old.key).length, 1)
+  assert.throws(() => store.unarchive(old.key), /isn't archived/)
+})
+
+test("goals: titled and described, one per task, progress always derived", () => {
+  const root = tempRoot()
+  const store = initProject(root, { name: "goals test", prefix: "GOA" })
+
+  // Created deliberately, slug derived from the title.
+  const goal = store.createGoal({
+    title: "Trust & guardrail layer",
+    description: "Why: DialMCP context lives here once, not in every ticket.",
+  })
+  assert.equal(goal.slug, "trust-guardrail-layer")
+  assert.throws(() => store.createGoal({ title: "Trust & guardrail layer" }), /already exists/)
+  assert.throws(() => store.createGoal({ title: "x", slug: "archive" }), /invalid goal slug/)
+  assert.throws(() => store.createGoal({ title: "x", slug: "Not A Slug" }), /invalid goal slug/)
+
+  // Assignment is validated: a goal must exist before a task can belong to it.
+  assert.throws(() => store.create({ title: "T", goal: "nope" }), /no such goal/)
+  const a = store.create({ title: "First", goal: goal.slug })
+  const b = store.create({ title: "Second" })
+  store.update(b.key, { goal: goal.slug })
+  assert.equal(store.get(b.key)!.goal, goal.slug)
+  assert.deepEqual(store.list({ goal: goal.slug }).map((t) => t.key), [a.key, b.key])
+
+  // The file is the state: goal ref serialized on the ticket, goal file on disk.
+  assert.match(
+    readFileSync(join(root, ".task", "tickets", a.key, "ticket.md"), "utf8"),
+    /goal: "trust-guardrail-layer"/,
+  )
+  const goalFile = readFileSync(join(root, ".task", "goals", "trust-guardrail-layer.md"), "utf8")
+  assert.match(goalFile, /# Trust & guardrail layer/)
+
+  // Update touches the file; clearing a task's goal is `goal: null`.
+  store.updateGoal(goal.slug, { description: "Sharper why." })
+  assert.equal(store.getGoal(goal.slug)!.description, "Sharper why.")
+  store.update(b.key, { goal: null })
+  assert.equal(store.get(b.key)!.goal, null)
+
+  // Archive refuses while open work references the goal, allows after.
+  assert.throws(
+    () => store.archiveGoal(goal.slug),
+    new RegExp(`still has open tasks \\(GOA-${a.key}\\)`),
+  )
+  store.update(a.key, { status: "done" })
+  const shelved = store.archiveGoal(goal.slug)
+  assert.equal(shelved.archived, true)
+  assert.deepEqual(store.goals().map((g) => g.slug), [])
+  assert.deepEqual(store.goals(true).map((g) => g.slug), [goal.slug])
+  // Still resolvable (done tickets keep their ref readable), not assignable.
+  assert.equal(store.getGoal(goal.slug)!.title, "Trust & guardrail layer")
+  assert.throws(() => store.update(b.key, { goal: goal.slug }), /is archived — run/)
+  assert.throws(() => store.updateGoal(goal.slug, { title: "x" }), /is archived — run/)
+
+  // Delete needs every live ref cleared first — pruning organization is a
+  // human call, so the human makes it.
+  store.unarchiveGoal(goal.slug)
+  assert.throws(() => store.deleteGoal(goal.slug), new RegExp(`referenced by GOA-${a.key}`))
+  store.update(a.key, { goal: null })
+  store.deleteGoal(goal.slug)
+  assert.equal(store.getGoal(goal.slug), null)
 })
 
 test("prefix routing helpers find the right board from anywhere", () => {
@@ -276,26 +326,26 @@ test("prefix routing helpers find the right board from anywhere", () => {
 test("concurrent-writer shapes merge by construction", () => {
   const root = tempRoot()
   const store = initProject(root, { name: "merge" })
-  const task = store.create({ title: "Contended" })
+  const task = store.create({ title: "Contended", status: "todo" })
 
   // Two agents commenting at once = two files; simulate the second writer by
   // dropping its file in directly, the way a git merge would.
-  store.addComment(task.number, "from session one", "claude")
-  const commentsDir = join(root, ".task", "tickets", String(task.number), "comments")
+  store.addComment(task.key, "from session one", "claude")
+  const commentsDir = join(root, ".task", "tickets", task.key, "comments")
   writeFileSync(
     join(commentsDir, "2026-08-15T170000-other.md"),
     "---\nauthor: \"other\"\ncreated: 2026-08-15T17:00:00.000Z\n---\n\nfrom session two\n",
   )
-  assert.equal(store.comments(task.number).length, 2)
+  assert.equal(store.comments(task.key).length, 2)
 
   // A claim is a one-line diff: exactly one meaningful frontmatter line
   // changes. `updated:` is excluded because it only changes when the update
   // lands in a different millisecond than the create — true except when this
   // test runs fast enough, which is exactly the kind of coin-flip a test must
   // not depend on.
-  const path = join(root, ".task", "tickets", String(task.number), "ticket.md")
+  const path = join(root, ".task", "tickets", task.key, "ticket.md")
   const before = readFileSync(path, "utf8").split("\n")
-  store.update(task.number, { status: "in_progress", position: task.position })
+  store.update(task.key, { status: "in_progress", position: task.position })
   const after = readFileSync(path, "utf8").split("\n")
   const changed = before.filter((line, i) => after[i] !== line)
   assert.deepEqual(