@nickmeriano/task 0.7.0 → 0.8.0

package/src/promote.test.ts

@@ -0,0 +1,131 @@
+/**
+ * `task promote` — from the outside (real CLI subprocesses, exit codes are
+ * the contract):
+ *
+ * 1. Any backlog ticket promotes to todo, exit 0 — there is no quality gate;
+ *    planning happens at claim time.
+ * 2. Only backlog tickets promote — todo/in_progress/done are refused.
+ * 3. Blocked and needs-human tickets still promote, with the hold reported
+ *    (stdout note, `holds` in --json) — those are claim-time gates.
+ * 4. `task add` with no --status lands in backlog: the dump list is the
+ *    default, todo is the deliberate choice promote makes.
+ */
+
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { execFile } from "node:child_process"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { initProject } from "./file-store.ts"
+import type { Task } from "./types.ts"
+
+const CLI = fileURLToPath(new URL("./cli.ts", import.meta.url))
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "task-promote-test-"))
+  process.on("exit", () => rmSync(dir, { recursive: true, force: true }))
+  return dir
+}
+
+interface CliResult {
+  code: number
+  stdout: string
+  stderr: string
+}
+
+/** The CLI as callers see it — a subprocess with an exit code. */
+function cli(cwd: string, ...args: string[]): Promise<CliResult> {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      ["--experimental-strip-types", CLI, ...args],
+      { cwd },
+      (error, stdout, stderr) => {
+        resolve({ code: error ? ((error as { code?: number }).code ?? 1) : 0, stdout, stderr })
+      },
+    )
+  })
+}
+
+/**
+ * A board with every promotion shape. Promotion never touches git, so a bare
+ * .task/ directory is the whole fixture:
+ *   1 "One-liner"      backlog (no tags — nothing else required)
+ *   2 "Also backlog"   backlog
+ *   3 "Blocked"        backlog, blocked by 2
+ *   4 "For a person"   backlog, needs-human
+ *   5 "Already queued" todo
+ */
+function fixture(): string {
+  const dir = tempDir()
+  const store = initProject(dir, { name: "promote board", prefix: "PRO" })
+  store.create({ title: "One-liner", status: "backlog" })
+  store.create({ title: "Also backlog", status: "backlog" })
+  store.create({ title: "Blocked", status: "backlog", blockedBy: [2] })
+  store.create({ title: "For a person", status: "backlog", needsHuman: true })
+  store.create({ title: "Already queued", status: "todo" })
+  store.close()
+  return dir
+}
+
+async function show(dir: string, id: string): Promise<Task> {
+  const result = await cli(dir, "show", id, "--json")
+  assert.equal(result.code, 0, result.stderr)
+  return (JSON.parse(result.stdout) as { task: Task }).task
+}
+
+test("any backlog ticket promotes to todo — no quality gate", async () => {
+  const dir = fixture()
+  const result = await cli(dir, "promote", "PRO-1", "--json")
+  assert.equal(result.code, 0, result.stderr)
+  const { task, holds } = JSON.parse(result.stdout) as { task: Task; holds: string[] }
+  assert.equal(task.status, "todo")
+  assert.deepEqual(holds, [])
+  assert.equal((await show(dir, "PRO-1")).status, "todo")
+})
+
+test("only backlog tickets promote", async () => {
+  const dir = fixture()
+  const result = await cli(dir, "promote", "PRO-5")
+  assert.equal(result.code, 2)
+  assert.match(result.stderr, /is todo — only backlog tickets/)
+})
+
+test("blocked and needs-human tickets promote with the hold reported", async () => {
+  const dir = fixture()
+  const blocked = await cli(dir, "promote", "PRO-3", "--json")
+  assert.equal(blocked.code, 0, blocked.stderr)
+  const parsed = JSON.parse(blocked.stdout) as { task: Task; holds: string[] }
+  assert.equal(parsed.task.status, "todo")
+  assert.deepEqual(parsed.holds, ["blocked by PRO-2"])
+
+  const person = await cli(dir, "promote", "PRO-4")
+  assert.equal(person.code, 0, person.stderr)
+  assert.match(person.stdout, /needs-human — in todo, but not claimable/)
+  assert.equal((await show(dir, "PRO-4")).status, "todo")
+})
+
+test("task add with no --status lands in backlog", async () => {
+  const dir = fixture()
+  const added = await cli(dir, "add", "Dumped in passing", "--json")
+  assert.equal(added.code, 0, added.stderr)
+  const { task } = JSON.parse(added.stdout) as { task: Task }
+  assert.equal(task.status, "backlog")
+})
+
+test("--description-file reads markdown from disk; combining both flags refuses", async () => {
+  const dir = fixture()
+  const body = "## Plan\n\nA description with \"quotes\", `backticks`,\nand $(subshells) that never touch a shell.\n"
+  writeFileSync(join(dir, "desc.md"), body)
+
+  const added = await cli(dir, "add", "From a file", "--description-file", "desc.md", "--json")
+  assert.equal(added.code, 0, added.stderr)
+  const { task } = JSON.parse(added.stdout) as { task: Task }
+  assert.match(task.description ?? "", /"quotes", `backticks`,\nand \$\(subshells\)/)
+
+  const both = await cli(dir, "update", task.id, "--description", "x", "--description-file", "desc.md")
+  assert.equal(both.code, 1)
+  assert.match(both.stderr, /not both/)
+})

package/src/search.test.ts

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { initProject } from "./file-store.ts"
+import { searchStore } from "./search.ts"
+
+function tempRoot(): string {
+  const dir = mkdtempSync(join(tmpdir(), "task-search-"))
+  process.on("exit", () => rmSync(dir, { recursive: true, force: true }))
+  return dir
+}
+
+test("search covers titles, descriptions and comments, case-insensitively", () => {
+  const store = initProject(tempRoot(), { name: "search", prefix: "SRC" })
+  const a = store.create({ title: "Wire up Webhook retries", description: "exponential backoff" })
+  const b = store.create({ title: "Unrelated", description: "The webhook queue drains here." })
+  const c = store.create({ title: "Also unrelated" })
+  store.create({ title: "Noise" })
+  store.addComment(c.number, "root cause: the WEBHOOK signature check", "claude")
+
+  const results = searchStore(store, "webhook", {}, false)
+  assert.deepEqual(
+    results.map((r) => r.task.number).sort(),
+    [a.number, b.number, c.number],
+  )
+  const byNumber = new Map(results.map((r) => [r.task.number, r.matches]))
+  assert.deepEqual(byNumber.get(a.number)!.map((m) => m.field), ["title"])
+  assert.equal(byNumber.get(b.number)![0].snippet, "The webhook queue drains here.")
+  const comment = byNumber.get(c.number)![0]
+  assert.equal(comment.field, "comment")
+  assert.equal(comment.author, "claude")
+  assert.match(comment.snippet, /WEBHOOK signature/)
+})
+
+test("filters scope the search; --archived adds the archive in", () => {
+  const store = initProject(tempRoot(), { name: "scope", prefix: "SCP" })
+  const live = store.create({ title: "deploy pipeline", tags: ["infra"] })
+  store.create({ title: "deploy docs", tags: ["docs"] })
+  const old = store.create({ title: "deploy v1", status: "done" })
+  store.archive(old.number)
+
+  assert.deepEqual(
+    searchStore(store, "deploy", { tags: ["infra"] }, false).map((r) => r.task.number),
+    [live.number],
+  )
+  const withArchive = searchStore(store, "deploy", {}, true)
+  assert.ok(withArchive.some((r) => r.task.number === old.number && r.task.archived))
+  assert.equal(withArchive.length, 3)
+  // Without the flag the archived ticket stays out.
+  assert.equal(searchStore(store, "deploy", {}, false).length, 2)
+})
+
+test("long lines are windowed so the hit is visible", () => {
+  const store = initProject(tempRoot(), { name: "win", prefix: "WIN" })
+  const filler = "x".repeat(150)
+  store.create({ title: "Long", description: `${filler} needle in here ${filler}` })
+  const [result] = searchStore(store, "needle", {}, false)
+  assert.ok(result.matches[0].snippet.length <= 102) // window + ellipses
+  assert.match(result.matches[0].snippet, /needle in here/)
+  assert.match(result.matches[0].snippet, /^…/)
+  assert.match(result.matches[0].snippet, /…$/)
+})

package/src/search.ts

@@ -0,0 +1,91 @@
+/**
+ * `task search` — find tickets by what they say, not just what they're tagged.
+ *
+ * Case-insensitive substring match over titles, descriptions and comments,
+ * scoped by the usual list filters. At current board sizes a straight scan of
+ * the parsed files is plenty; if boards ever grow to thousands of tickets,
+ * this is the one feature that would justify a derived FTS index — rebuilt
+ * from the files, never as state, which the text-canonical format was designed
+ * to allow.
+ */
+
+import type { Store } from "./store.ts"
+import { STATUSES, type Task, type TaskFilter } from "./types.ts"
+
+export interface SearchMatch {
+  field: "title" | "description" | "comment"
+  /** The matching line, trimmed and windowed around the first hit. */
+  snippet: string
+  /** Set on comment matches. */
+  commentId?: string
+  author?: string
+}
+
+export interface SearchResult {
+  task: Task
+  matches: SearchMatch[]
+}
+
+/** How much of a matching line a snippet shows. */
+const SNIPPET_MAX = 100
+
+/** The first line containing the needle, windowed so the hit is visible. */
+function snippetOf(text: string, needle: string): string {
+  const lines = text.split("\n")
+  const line = (lines.find((l) => l.toLowerCase().includes(needle)) ?? lines[0]).trim()
+  if (line.length <= SNIPPET_MAX) return line
+  const at = line.toLowerCase().indexOf(needle)
+  const start = Math.max(0, Math.min(at - 30, line.length - SNIPPET_MAX))
+  const end = Math.min(line.length, start + SNIPPET_MAX)
+  return `${start > 0 ? "…" : ""}${line.slice(start, end).trim()}${end < line.length ? "…" : ""}`
+}
+
+/**
+ * Every task matching `query`, with one snippet per matching field (and one
+ * per matching comment). `includeArchived` searches the archive *in addition
+ * to* the board — unlike `list --archived`, which shows the archive instead,
+ * a search is a question about everything ever written down.
+ */
+export function searchStore(
+  store: Store,
+  query: string,
+  filter: TaskFilter,
+  includeArchived: boolean,
+): SearchResult[] {
+  const needle = query.toLowerCase()
+  const pool = [
+    ...store.list(filter),
+    ...(includeArchived ? store.list({ ...filter, archived: true }) : []),
+  ]
+
+  const results: SearchResult[] = []
+  for (const task of pool) {
+    const matches: SearchMatch[] = []
+    if (task.title.toLowerCase().includes(needle)) {
+      matches.push({ field: "title", snippet: snippetOf(task.title, needle) })
+    }
+    if (task.description.toLowerCase().includes(needle)) {
+      matches.push({ field: "description", snippet: snippetOf(task.description, needle) })
+    }
+    for (const comment of store.comments(task.number)) {
+      if (!comment.body.toLowerCase().includes(needle)) continue
+      matches.push({
+        field: "comment",
+        snippet: snippetOf(comment.body, needle),
+        commentId: comment.id,
+        ...(comment.author ? { author: comment.author } : {}),
+      })
+    }
+    if (matches.length > 0) results.push({ task, matches })
+  }
+
+  // Board order — grouped by status column, then position — same as `list`.
+  const order = new Map(STATUSES.map((s, i) => [s, i]))
+  results.sort(
+    (a, b) =>
+      order.get(a.task.status)! - order.get(b.task.status)! ||
+      a.task.position - b.task.position ||
+      a.task.number - b.task.number,
+  )
+  return results
+}

package/src/server.ts

@@ -45,8 +45,8 @@ function parsePatch(body: Record<string, unknown>): TaskPatch {
     patch.status = body.status
   }
   if (Array.isArray(body.tags)) patch.tags = body.tags.map(String)
-  if (typeof body.milestone === "string" || body.milestone === null) {
-    patch.milestone = body.milestone === "" ? null : body.milestone
+  if (typeof body.goal === "string" || body.goal === null) {
+    patch.goal = body.goal === "" ? null : body.goal
   }
   if (typeof body.needsHuman === "boolean") patch.needsHuman = body.needsHuman
   if (Array.isArray(body.blocks)) patch.blocks = body.blocks.map(taskNumber)
@@ -223,6 +223,15 @@ export function createTaskServer(serveRoot: string): Server {
       return
     }
 
+    if (path === "/api/goals" && req.method === "GET") {
+      // Read-only on purpose: a goal is created deliberately, with a
+      // description, via `task goal add` — a picker that mints goals from
+      // typed strings would just be milestones with extra steps. Archived
+      // goals ride along flagged, so old chips can still resolve a title.
+      json(res, 200, { goals: [...store.goals(), ...store.goals(true)] })
+      return
+    }
+
     if (path === "/api/tasks" && req.method === "GET") {
       const counts = store.commentCounts()
       const tasks = store

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,9 @@ 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 { FileStore, initProject, openBoard } from "./file-store.ts"
 import { parseTicket, serializeTicket, type TicketDoc } from "./ticket-doc.ts"
-import { TaskStore, findBoardsByPrefix, findScopeRoot } from "./store.ts"
+import { findBoardsByPrefix, findScopeRoot } from "./store.ts"
 
 function tempRoot(): string {
   const dir = mkdtempSync(join(tmpdir(), "task-test-"))
@@ -31,7 +30,7 @@ test("ticket documents round-trip, including the awkward bodies", () => {
       description: "One line.",
       status: "todo",
       tags: [],
-      milestone: null,
+      goal: null,
       needsHuman: false,
       blockedBy: [],
       prs: [],
@@ -46,7 +45,7 @@ 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",
+      goal: "v2-storage",
       needsHuman: true,
       blockedBy: [3, 7],
       prs: ["https://github.com/x/y/pull/1"],
@@ -59,7 +58,7 @@ test("ticket documents round-trip, including the awkward bodies", () => {
       description: "",
       status: "backlog",
       tags: [],
-      milestone: null,
+      goal: null,
       needsHuman: false,
       blockedBy: [],
       prs: [],
@@ -77,7 +76,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 +87,16 @@ 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 spelling still reads as the goal — old boards keep rendering,
+  // and `task check --fix`'s canonical rewrite is the migration.
+  const legacy = parseTicket(text.replace("goal: launch", "milestone: launch"), "test")
+  assert.equal(legacy.goal, "launch")
+  assert.match(serializeTicket(legacy), /goal: "launch"/)
+  assert.doesNotMatch(serializeTicket(legacy), /milestone/)
+
   assert.throws(
     () => parseTicket(text.replace("status: todo", "status: todoo"), "here"),
     /here.*invalid status/,
@@ -104,7 +110,7 @@ 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])
@@ -153,70 +159,39 @@ test("FileStore keeps the store's contract", () => {
   assert.equal(d.number, 4)
 })
 
-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" })
+  const keep = store.create({ title: "Still open", status: "todo" })
+  const old = store.create({ title: "Finished work", status: "todo" })
   store.link(keep.number, "blocked_by", old.number)
   store.addComment(old.number, "how it went", "nick")
 
@@ -258,6 +233,63 @@ test("archive moves finished tickets off the hot path, losing nothing", () => {
   assert.throws(() => store.unarchive(old.number), /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.number, { goal: goal.slug })
+  assert.equal(store.get(b.number)!.goal, goal.slug)
+  assert.deepEqual(store.list({ goal: goal.slug }).map((t) => t.number), [a.number, b.number])
+
+  // The file is the state: goal ref serialized on the ticket, goal file on disk.
+  assert.match(
+    readFileSync(join(root, ".task", "tickets", "1", "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.number, { goal: null })
+  assert.equal(store.get(b.number)!.goal, null)
+
+  // Archive refuses while open work references the goal, allows after.
+  assert.throws(() => store.archiveGoal(goal.slug), /still has open tasks \(GOA-1\)/)
+  store.update(a.number, { 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.number, { 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), /referenced by GOA-1/)
+  store.update(a.number, { goal: null })
+  store.deleteGoal(goal.slug)
+  assert.equal(store.getGoal(goal.slug), null)
+})
+
 test("prefix routing helpers find the right board from anywhere", () => {
   const repo = tempRoot()
   initProject(repo, { name: "root board", prefix: "NIC" })
@@ -276,7 +308,7 @@ 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.