@dailephd/my-dev-kit-lab 0.8.1 → 0.9.0

package/benchmarks/projects/agent-success-inventory-node/tests/report-primary.check.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createInventorySystem } from "../src/index.js";
+
+test("the report distinguishes active, fulfilled and cancelled reservations", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 3 });
+  service.reserve({ reservationId: "r-2", sku: "widget", quantity: 2 });
+  service.reserve({ reservationId: "r-3", sku: "widget", quantity: 1 });
+  service.cancel("r-1");
+  service.fulfill("r-2");
+  const [row] = report().skus;
+  assert.equal(row.sku, "widget");
+  assert.deepEqual(row.active, { count: 1, quantity: 1 });
+  assert.deepEqual(row.fulfilled, { count: 1, quantity: 2 });
+  assert.deepEqual(row.cancelled, { count: 1, quantity: 3 });
+});
+
+test("cancellation restores exactly the reserved quantity", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 10);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 4 });
+  assert.equal(store.getItem("widget").available, 6);
+  const cancelled = service.cancel("r-1");
+  assert.equal(cancelled.status, "cancelled");
+  assert.equal(store.getItem("widget").available, 10);
+});
+
+test("reported totals agree with the underlying store", () => {
+  const { store, service, report } = createInventorySystem();
+  store.addStock("widget", 10);
+  store.addStock("gadget", 6);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 3 });
+  service.reserve({ reservationId: "r-2", sku: "gadget", quantity: 2 });
+  service.reserve({ reservationId: "r-3", sku: "gadget", quantity: 1 });
+  service.cancel("r-1");
+  service.fulfill("r-2");
+  const result = report();
+  for (const row of result.skus) {
+    const item = store.getItem(row.sku);
+    assert.equal(row.available, item.available);
+    assert.equal(row.received, item.received);
+    assert.equal(row.received, row.available + row.active.quantity + row.fulfilled.quantity);
+  }
+  assert.deepEqual(result.totals, { received: 16, available: 13, active: 1, fulfilled: 2, cancelled: 3 });
+});

package/benchmarks/projects/agent-success-inventory-node/tests/reservation-edge.check.mjs

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createInventorySystem } from "../src/index.js";
+
+test("a duplicate reservation id does not consume stock twice", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 }), {
+    code: "DUPLICATE_RESERVATION"
+  });
+  assert.equal(store.getItem("widget").available, 3);
+  assert.equal(store.listReservations().length, 1);
+});
+
+test("a duplicate id for another sku changes neither sku nor the original record", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  store.addStock("gadget", 5);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 2 });
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "gadget", quantity: 4 }), {
+    code: "DUPLICATE_RESERVATION"
+  });
+  assert.equal(store.getItem("gadget").available, 5);
+  assert.equal(store.getItem("widget").available, 3);
+  assert.deepEqual(store.getReservation("r-1"), { id: "r-1", sku: "widget", quantity: 2, status: "active" });
+});
+
+test("a failed reservation id can be used again by a later valid reservation", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 3);
+  assert.throws(() => service.reserve({ reservationId: "r-9", sku: "widget", quantity: 99 }), {
+    code: "INSUFFICIENT_STOCK"
+  });
+  service.reserve({ reservationId: "r-9", sku: "widget", quantity: 1 });
+  assert.equal(store.getItem("widget").available, 2);
+  assert.equal(store.listReservations().length, 1);
+});
+
+test("unrelated inventory items stay unchanged through failures and successes", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 4);
+  store.addStock("gadget", 7);
+  const gadgetBefore = store.getItem("gadget");
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: 5 }), {
+    code: "INSUFFICIENT_STOCK"
+  });
+  service.reserve({ reservationId: "r-2", sku: "widget", quantity: 4 });
+  assert.deepEqual(store.getItem("gadget"), gadgetBefore);
+  assert.equal(store.getItem("widget").available, 0);
+});
+
+test("stock never goes negative after repeated failing attempts", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 1);
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    assert.throws(() => service.reserve({ reservationId: `r-${attempt}`, sku: "widget", quantity: 2 }), {
+      code: "INSUFFICIENT_STOCK"
+    });
+  }
+  assert.equal(store.getItem("widget").available, 1);
+  assert.deepEqual(store.listReservations(), []);
+});

package/benchmarks/projects/agent-success-inventory-node/tests/reservation-primary.check.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createInventorySystem } from "../src/index.js";
+
+test("a reservation that exceeds stock fails without consuming any stock", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: 8 }), {
+    code: "INSUFFICIENT_STOCK"
+  });
+  assert.equal(store.getItem("widget").available, 5);
+});
+
+test("a failed reservation leaves no reservation record", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 2);
+  assert.throws(() => service.reserve({ reservationId: "r-1", sku: "widget", quantity: 3 }), {
+    code: "INSUFFICIENT_STOCK"
+  });
+  assert.throws(() => service.reserve({ reservationId: "r-2", sku: "missing", quantity: 1 }), {
+    code: "UNKNOWN_SKU"
+  });
+  assert.deepEqual(store.listReservations(), []);
+});
+
+test("a successful reservation decrements stock exactly once", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  const reservation = service.reserve({ reservationId: "r-1", sku: "widget", quantity: 3 });
+  assert.deepEqual(reservation, { id: "r-1", sku: "widget", quantity: 3, status: "active" });
+  assert.equal(store.getItem("widget").available, 2);
+  assert.equal(store.listReservations().length, 1);
+});
+
+test("reserving exactly the available stock succeeds and leaves none", () => {
+  const { store, service } = createInventorySystem();
+  store.addStock("widget", 5);
+  service.reserve({ reservationId: "r-1", sku: "widget", quantity: 5 });
+  assert.equal(store.getItem("widget").available, 0);
+  assert.throws(() => service.reserve({ reservationId: "r-2", sku: "widget", quantity: 1 }), {
+    code: "INSUFFICIENT_STOCK"
+  });
+  assert.equal(store.getItem("widget").available, 0);
+});

package/benchmarks/projects/agent-success-task-board-node/.gitattributes

@@ -0,0 +1,2 @@
+# Keep checked-out bytes identical on every platform so reference patches apply deterministically.
+* text eol=lf

package/benchmarks/projects/agent-success-task-board-node/README.md

@@ -0,0 +1,77 @@
+# agent-success-task-board-node
+
+A small, dependency-free, in-memory task board written as JavaScript ES modules for Node.js `>=24`.
+
+This project is an **implementation benchmark** for the `agent-success-rate` experiment of
+`my-dev-kit-lab`. It is a controlled fixture: the Lab copies it into a disposable sandbox, asks an
+implementation to change code under `src/`, and judges the result with trusted checks that the
+implementation does not receive. The project is not a product and has no persistence, network access,
+environment dependence, randomness or timestamps.
+
+## Behavior
+
+The board models task creation, storage, external-task import, project ownership, completion and
+per-project summaries. All state lives in memory inside one board instance; two boards never share state.
+
+- A task has `id`, `title`, `projectId`, `externalId` (`null` for manually created tasks) and `completed`.
+- Task ids are sequential per board: `task-1`, `task-2`, ... An operation that is rejected does not
+  consume an id and does not change the store.
+- A **title** is a non-empty string once surrounding whitespace is removed. Surrounding whitespace is not
+  part of the stored title; interior whitespace is kept. Invalid titles fail with a `ValidationError`
+  whose `code` is `INVALID_TITLE`.
+- A **project identity** is the project id trimmed and lower-cased. Tasks created without a project belong
+  to `inbox`. A blank project id fails with a `ValidationError` whose `code` is `INVALID_PROJECT`.
+  A project's tasks are exactly the tasks with that identity; other projects, including projects whose
+  names merely start with the same text, are unrelated.
+- An **external id** identifies a task in an external system. It is compared after trimming and
+  lower-casing, and the normalized form is what the board stores. An import without a usable external id
+  fails with a `ValidationError` whose `code` is `INVALID_EXTERNAL_ID`.
+- **Import** processes items in input order. An item whose external id is already known, from an earlier
+  call or earlier in the same call, is skipped instead of creating a duplicate.
+- Tasks that were created manually are never removed by imports.
+- A **summary** reports one project's `total`, `completed` and `open` counts and the ids of its tasks in
+  creation order. `completed` can never exceed `total`, and tasks of other projects never change a
+  project's summary.
+
+## Public API
+
+Everything is exported from `src/index.js`.
+
+| Export | Purpose |
+| --- | --- |
+| `createTaskBoard()` | Returns `{ store, service, summarize }` for a fresh, independent board. |
+| `TaskService` | `createTask({ title, projectId? })`, `completeTask(id)`, `importTasks(items)`. |
+| `TaskStore` | `nextId()`, `add(task)`, `get(id)`, `list()`, `update(id, changes)`, `findByExternalId(key)`. |
+| `summarizeProject(store, projectId)` | Returns `{ projectId, total, completed, open, taskIds }`. |
+| `validateTitle(title)` | Returns the normalized title or throws `ValidationError`. |
+| `normalizeProjectId(projectId)` | Returns the normalized project identity or throws `ValidationError`. |
+| `normalizeExternalId(externalId)` | Returns the identity key used to compare external ids. |
+| `ValidationError`, `TaskNotFoundError` | Error classes with a stable `code` property. |
+| `INVALID_TITLE`, `INVALID_PROJECT`, `INVALID_EXTERNAL_ID` | Validation error codes. |
+
+`importTasks(items)` takes `{ externalId, title, projectId? }` items and returns
+`{ imported, skipped }`: the created tasks, and the normalized external ids that were skipped.
+
+Stores return copies of tasks, so changing a returned object never changes the board.
+
+## Layout
+
+```
+src/validation.js       title, project and error contracts
+src/taskStore.js        in-memory storage and external-id identity
+src/taskService.js      task creation, completion and import
+src/projectSummary.js   per-project summaries
+src/index.js            public exports and createTaskBoard()
+tests/*.check.mjs       trusted verification checks (owned by the Lab verifier)
+```
+
+## Running checks
+
+```
+npm test
+node --test tests/regression.check.mjs
+```
+
+The files under `tests/` are named `*.check.mjs` on purpose and are run explicitly through Node's built-in
+test runner. They are verification inputs owned by the Lab, not part of the implementation to change.
+No installation step is needed.

package/benchmarks/projects/agent-success-task-board-node/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "agent-success-task-board-node",
+  "version": "0.0.0",
+  "description": "Dependency-free JavaScript implementation benchmark: an in-memory task board.",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "node --test \"tests/*.check.mjs\""
+  }
+}

package/benchmarks/projects/agent-success-task-board-node/src/index.js

@@ -0,0 +1,24 @@
+import { summarizeProject } from "./projectSummary.js";
+import { TaskService } from "./taskService.js";
+import { TaskStore } from "./taskStore.js";
+
+export { summarizeProject } from "./projectSummary.js";
+export { TaskService } from "./taskService.js";
+export { TaskNotFoundError, TaskStore, normalizeExternalId } from "./taskStore.js";
+export {
+  INVALID_EXTERNAL_ID,
+  INVALID_PROJECT,
+  INVALID_TITLE,
+  ValidationError,
+  normalizeProjectId,
+  validateTitle
+} from "./validation.js";
+
+/**
+ * Creates an independent in-memory board: a store, a service over it, and a summary helper.
+ */
+export function createTaskBoard() {
+  const store = new TaskStore();
+  const service = new TaskService(store);
+  return { store, service, summarize: (projectId) => summarizeProject(store, projectId) };
+}

package/benchmarks/projects/agent-success-task-board-node/src/projectSummary.js

@@ -0,0 +1,15 @@
+/**
+ * Summarizes the tasks of one project. Task ids are listed in creation order.
+ */
+export function summarizeProject(store, projectId) {
+  const all = store.list();
+  const tasks = all.filter((task) => task.projectId.startsWith(projectId));
+  const completed = all.filter((task) => task.completed).length;
+  return {
+    projectId,
+    total: tasks.length,
+    completed,
+    open: tasks.length - completed,
+    taskIds: tasks.map((task) => task.id)
+  };
+}

package/benchmarks/projects/agent-success-task-board-node/src/taskService.js

@@ -0,0 +1,58 @@
+import { TaskNotFoundError, normalizeExternalId } from "./taskStore.js";
+import { INVALID_EXTERNAL_ID, ValidationError, validateTitle } from "./validation.js";
+
+const DEFAULT_PROJECT = "inbox";
+
+export class TaskService {
+  constructor(store) {
+    this.store = store;
+  }
+
+  createTask({ title, projectId = DEFAULT_PROJECT } = {}) {
+    const normalizedTitle = validateTitle(title);
+    return this.store.add({
+      id: this.store.nextId(),
+      title: normalizedTitle,
+      projectId,
+      externalId: null,
+      completed: false
+    });
+  }
+
+  completeTask(id) {
+    if (!this.store.get(id)) {
+      throw new TaskNotFoundError(id);
+    }
+    return this.store.update(id, { completed: true });
+  }
+
+  /**
+   * Imports external tasks in input order. Returns the tasks that were created and the
+   * external identifiers that were skipped because the task was already imported.
+   */
+  importTasks(items) {
+    const imported = [];
+    const skipped = [];
+    for (const item of items) {
+      if (typeof item?.externalId !== "string" || item.externalId.trim() === "") {
+        throw new ValidationError(INVALID_EXTERNAL_ID, "external id must be a non-empty string");
+      }
+      const externalId = normalizeExternalId(item.externalId);
+      if (this.store.findByExternalId(item.externalId)) {
+        skipped.push(externalId);
+        continue;
+      }
+      const title = validateTitle(item.title);
+      imported.push(
+        this.store.add({
+          id: this.store.nextId(),
+          title,
+          projectId: item.projectId ?? DEFAULT_PROJECT,
+          externalId,
+          completed: false
+        })
+      );
+    }
+    return { imported, skipped };
+  }
+}

package/benchmarks/projects/agent-success-task-board-node/src/taskStore.js

@@ -0,0 +1,58 @@
+export class TaskNotFoundError extends Error {
+  constructor(id) {
+    super(`task not found: ${id}`);
+    this.name = "TaskNotFoundError";
+    this.code = "TASK_NOT_FOUND";
+  }
+}
+
+/**
+ * Returns the identity key used to compare external task identifiers.
+ */
+export function normalizeExternalId(externalId) {
+  return String(externalId).trim();
+}
+
+/**
+ * In-memory task storage. Tasks are returned as copies, in insertion order.
+ */
+export class TaskStore {
+  #tasks = [];
+  #sequence = 0;
+
+  nextId() {
+    this.#sequence += 1;
+    return `task-${this.#sequence}`;
+  }
+
+  add(task) {
+    this.#tasks.push({ ...task });
+    return { ...task };
+  }
+
+  get(id) {
+    const task = this.#tasks.find((candidate) => candidate.id === id);
+    return task ? { ...task } : null;
+  }
+
+  list() {
+    return this.#tasks.map((task) => ({ ...task }));
+  }
+
+  update(id, changes) {
+    const task = this.#tasks.find((candidate) => candidate.id === id);
+    if (!task) {
+      throw new TaskNotFoundError(id);
+    }
+    Object.assign(task, changes);
+    return { ...task };
+  }
+
+  /**
+   * Finds a task by an already-normalized external identifier key.
+   */
+  findByExternalId(externalId) {
+    const task = this.#tasks.find((candidate) => candidate.externalId === externalId);
+    return task ? { ...task } : null;
+  }
+}

package/benchmarks/projects/agent-success-task-board-node/src/validation.js

@@ -0,0 +1,31 @@
+export const INVALID_TITLE = "INVALID_TITLE";
+export const INVALID_PROJECT = "INVALID_PROJECT";
+export const INVALID_EXTERNAL_ID = "INVALID_EXTERNAL_ID";
+
+export class ValidationError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "ValidationError";
+    this.code = code;
+  }
+}
+
+/**
+ * Returns the normalized title for a task, or throws ValidationError(INVALID_TITLE).
+ */
+export function validateTitle(title) {
+  if (typeof title !== "string" || title.length === 0) {
+    throw new ValidationError(INVALID_TITLE, "title must be a non-empty string");
+  }
+  return title;
+}
+
+/**
+ * Returns the normalized project identity, or throws ValidationError(INVALID_PROJECT).
+ */
+export function normalizeProjectId(projectId) {
+  if (typeof projectId !== "string") {
+    throw new ValidationError(INVALID_PROJECT, "project id must be a string");
+  }
+  return projectId.trim();
+}

package/benchmarks/projects/agent-success-task-board-node/tests/import-edge.check.mjs

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTaskBoard } from "../src/index.js";
+
+test("duplicates inside a single import call are collapsed to the first occurrence", () => {
+  const { service, store } = createTaskBoard();
+  const result = service.importTasks([
+    { externalId: "A-1", title: "First", projectId: "ops" },
+    { externalId: " a-1 ", title: "Second", projectId: "ops" },
+    { externalId: "b-2", title: "Third", projectId: "ops" }
+  ]);
+  assert.deepEqual(
+    result.imported.map((task) => task.title),
+    ["First", "Third"]
+  );
+  assert.deepEqual(result.skipped, ["a-1"]);
+  assert.equal(store.list().length, 2);
+});
+
+test("stored external identifiers use one normalized form", () => {
+  const { service, store } = createTaskBoard();
+  service.importTasks([
+    { externalId: "  MiXeD-9 ", title: "Mixed", projectId: "ops" },
+    { externalId: "UPPER-1", title: "Upper", projectId: "ops" }
+  ]);
+  assert.deepEqual(
+    store.list().map((task) => task.externalId),
+    ["mixed-9", "upper-1"]
+  );
+});
+
+test("import order is deterministic and ids follow input order", () => {
+  const run = () => {
+    const { service } = createTaskBoard();
+    return service
+      .importTasks([
+        { externalId: "z-1", title: "Z", projectId: "ops" },
+        { externalId: "a-1", title: "A", projectId: "ops" },
+        { externalId: "Z-1", title: "Z duplicate", projectId: "ops" }
+      ])
+      .imported.map((task) => [task.id, task.title, task.externalId]);
+  };
+  assert.deepEqual(run(), [
+    ["task-1", "Z", "z-1"],
+    ["task-2", "A", "a-1"]
+  ]);
+  assert.deepEqual(run(), run());
+});
+
+test("manually created tasks are kept and do not block imports", () => {
+  const { service, store } = createTaskBoard();
+  const manual = service.createTask({ title: "Manual task", projectId: "ops" });
+  service.importTasks([{ externalId: "ext-1", title: "Imported", projectId: "ops" }]);
+  service.importTasks([{ externalId: "EXT-1", title: "Imported", projectId: "ops" }]);
+  const titles = store.list().map((task) => task.title);
+  assert.deepEqual(titles, ["Manual task", "Imported"]);
+  assert.equal(store.get(manual.id).externalId, null);
+});
+
+test("skipped identifiers are reported in normalized form", () => {
+  const { service } = createTaskBoard();
+  service.importTasks([{ externalId: "ext-5", title: "Five", projectId: "ops" }]);
+  const second = service.importTasks([{ externalId: " EXT-5", title: "Five", projectId: "ops" }]);
+  assert.deepEqual(second.skipped, ["ext-5"]);
+});

package/benchmarks/projects/agent-success-task-board-node/tests/import-primary.check.mjs

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTaskBoard } from "../src/index.js";
+
+test("reimporting the same external task does not create a duplicate", () => {
+  const { service, store } = createTaskBoard();
+  service.importTasks([{ externalId: "ext-1", title: "Alpha", projectId: "ops" }]);
+  const second = service.importTasks([{ externalId: "ext-1", title: "Alpha", projectId: "ops" }]);
+  assert.equal(second.imported.length, 0);
+  assert.equal(store.list().length, 1);
+});
+
+test("external identifiers are compared after normalization across import calls", () => {
+  const { service, store } = createTaskBoard();
+  service.importTasks([{ externalId: "EXT-7", title: "Alpha", projectId: "ops" }]);
+  const second = service.importTasks([
+    { externalId: "  ext-7  ", title: "Alpha again", projectId: "ops" },
+    { externalId: "Ext-7", title: "Alpha once more", projectId: "ops" }
+  ]);
+  assert.equal(second.imported.length, 0);
+  assert.equal(second.skipped.length, 2);
+  assert.equal(store.list().length, 1);
+});
+
+test("new distinct external identifiers remain importable", () => {
+  const { service, store } = createTaskBoard();
+  service.importTasks([{ externalId: "ext-1", title: "Alpha", projectId: "ops" }]);
+  const second = service.importTasks([{ externalId: "EXT-2", title: "Beta", projectId: "ops" }]);
+  assert.equal(second.imported.length, 1);
+  assert.equal(store.list().length, 2);
+});

package/benchmarks/projects/agent-success-task-board-node/tests/regression.check.mjs

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  INVALID_EXTERNAL_ID,
+  INVALID_TITLE,
+  TaskNotFoundError,
+  createTaskBoard
+} from "../src/index.js";
+
+test("createTask stores an open task with a sequential id and a default project", () => {
+  const { service, store } = createTaskBoard();
+  const first = service.createTask({ title: "First" });
+  const second = service.createTask({ title: "Second", projectId: "ops" });
+  assert.deepEqual(first, { id: "task-1", title: "First", projectId: "inbox", externalId: null, completed: false });
+  assert.equal(second.id, "task-2");
+  assert.equal(second.projectId, "ops");
+  assert.deepEqual(
+    store.list().map((task) => task.id),
+    ["task-1", "task-2"]
+  );
+});
+
+test("missing, non-string and empty titles are rejected with the invalid-title error", () => {
+  const { service, store } = createTaskBoard();
+  for (const title of [undefined, null, 42, {}, ""]) {
+    assert.throws(() => service.createTask({ title }), { code: INVALID_TITLE });
+  }
+  assert.equal(store.list().length, 0);
+});
+
+test("already-trimmed titles are stored unchanged", () => {
+  const { service } = createTaskBoard();
+  assert.equal(service.createTask({ title: "Plain title" }).title, "Plain title");
+});
+
+test("completeTask marks a task completed, is idempotent and rejects unknown ids", () => {
+  const { service, store } = createTaskBoard();
+  const task = service.createTask({ title: "Finish me" });
+  assert.equal(service.completeTask(task.id).completed, true);
+  assert.equal(service.completeTask(task.id).completed, true);
+  assert.equal(store.get(task.id).completed, true);
+  assert.throws(() => service.completeTask("task-99"), (error) => error instanceof TaskNotFoundError);
+});
+
+test("returned tasks are copies and cannot mutate the store", () => {
+  const { service, store } = createTaskBoard();
+  const task = service.createTask({ title: "Immutable" });
+  task.title = "Changed";
+  store.list()[0].title = "Changed too";
+  assert.equal(store.get(task.id).title, "Immutable");
+});
+
+test("boards are independent of each other", () => {
+  const one = createTaskBoard();
+  const two = createTaskBoard();
+  one.service.createTask({ title: "Only in one" });
+  assert.equal(two.store.list().length, 0);
+  assert.equal(two.service.createTask({ title: "Fresh" }).id, "task-1");
+});
+
+test("importing the same external identifier twice does not duplicate it", () => {
+  const { service, store } = createTaskBoard();
+  const first = service.importTasks([{ externalId: "ext-1", title: "Imported", projectId: "ops" }]);
+  const second = service.importTasks([{ externalId: "ext-1", title: "Imported", projectId: "ops" }]);
+  assert.equal(first.imported.length, 1);
+  assert.deepEqual(second, { imported: [], skipped: ["ext-1"] });
+  assert.equal(store.list().length, 1);
+});
+
+test("distinct external identifiers import in input order and keep manual tasks", () => {
+  const { service, store } = createTaskBoard();
+  service.createTask({ title: "Manual", projectId: "ops" });
+  const { imported } = service.importTasks([
+    { externalId: "ext-2", title: "Two", projectId: "ops" },
+    { externalId: "ext-1", title: "One", projectId: "ops" }
+  ]);
+  assert.deepEqual(
+    imported.map((task) => task.externalId),
+    ["ext-2", "ext-1"]
+  );
+  assert.deepEqual(
+    store.list().map((task) => task.title),
+    ["Manual", "Two", "One"]
+  );
+});
+
+test("imports without a usable external identifier are rejected", () => {
+  const { service } = createTaskBoard();
+  for (const externalId of [undefined, null, "", "   ", 7]) {
+    assert.throws(() => service.importTasks([{ externalId, title: "No id" }]), { code: INVALID_EXTERNAL_ID });
+  }
+});
+
+test("a single-project summary counts total, completed and open tasks", () => {
+  const { service, summarize } = createTaskBoard();
+  const a = service.createTask({ title: "A", projectId: "web" });
+  service.createTask({ title: "B", projectId: "web" });
+  service.createTask({ title: "C", projectId: "web" });
+  service.completeTask(a.id);
+  assert.deepEqual(summarize("web"), {
+    projectId: "web",
+    total: 3,
+    completed: 1,
+    open: 2,
+    taskIds: ["task-1", "task-2", "task-3"]
+  });
+});