@sprintdock/backend 0.4.2

package/tests/infrastructure/drizzle-plan.repository.test.ts

@@ -0,0 +1,62 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Integration tests for DrizzlePlanRepository.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+test("plan CRUD and list ordering by created_at", async () => {
+  const db = await createTestDb();
+  const { plans } = createRepositories("sqlite", { sqlite: { db } });
+  const a = await plans.create({ slug: "a", title: "A" });
+  const b = await plans.create({ slug: "b", title: "B" });
+  assert.equal(a.slug, "a");
+  const listed = await plans.list();
+  assert.equal(listed.length, 2);
+  assert.equal(listed[0]?.id, a.id);
+  assert.equal(listed[1]?.id, b.id);
+  const bySlug = await plans.findBySlug("b");
+  assert.equal(bySlug?.title, "B");
+  const updated = await plans.update(b.id, { title: "B2" });
+  assert.equal(updated?.title, "B2");
+});
+
+test("setActive clears other plans and findActive returns that plan", async () => {
+  const db = await createTestDb();
+  const { plans } = createRepositories("sqlite", { sqlite: { db } });
+  const p1 = await plans.create({ slug: "p1", title: "One" });
+  const p2 = await plans.create({ slug: "p2", title: "Two" });
+  await plans.setActive(p1.id);
+  let active = await plans.findActive();
+  assert.equal(active?.id, p1.id);
+  assert.equal((await plans.findById(p1.id))?.isActive, true);
+  await plans.setActive(p2.id);
+  active = await plans.findActive();
+  assert.equal(active?.id, p2.id);
+  assert.equal((await plans.findById(p1.id))?.isActive, false);
+  assert.equal((await plans.findById(p2.id))?.isActive, true);
+});
+
+test("deleting plan cascades sprints and tasks", async () => {
+  const db = await createTestDb();
+  const { plans, sprints, tasks } = createRepositories("sqlite", { sqlite: { db } });
+  const plan = await plans.create({ slug: "plan", title: "P" });
+  const sp = await sprints.create({
+    slug: "s",
+    planId: plan.id,
+    name: "S",
+    goal: "G"
+  });
+  const tk = await tasks.create({
+    sprintId: sp.id,
+    title: "T",
+    priority: "medium"
+  });
+  const deleted = await plans.delete(plan.id);
+  assert.equal(deleted, true);
+  assert.equal(await sprints.findById(sp.id), null);
+  assert.equal(await tasks.findById(tk.id), null);
+});

package/tests/infrastructure/drizzle-sprint.repository.test.ts

@@ -0,0 +1,49 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Integration tests for DrizzleSprintRepository.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+test("create auto-assigns incrementing order per plan", async () => {
+  const db = await createTestDb();
+  const { plans, sprints } = createRepositories("sqlite", { sqlite: { db } });
+  const plan = await plans.create({ slug: "p", title: "P" });
+  const s1 = await sprints.create({
+    slug: "s1",
+    planId: plan.id,
+    name: "S1",
+    goal: "G"
+  });
+  const s2 = await sprints.create({
+    slug: "s2",
+    planId: plan.id,
+    name: "S2",
+    goal: "G"
+  });
+  assert.equal(s1.order, 0);
+  assert.equal(s2.order, 1);
+  const listed = await sprints.listByPlanId(plan.id);
+  assert.deepEqual(
+    listed.map((s) => s.slug),
+    ["s1", "s2"]
+  );
+});
+
+test("findBySlug uses plan_id and slug", async () => {
+  const db = await createTestDb();
+  const { plans, sprints } = createRepositories("sqlite", { sqlite: { db } });
+  const p = await plans.create({ slug: "p", title: "P" });
+  await sprints.create({
+    slug: "same",
+    planId: p.id,
+    name: "A",
+    goal: "G"
+  });
+  const found = await sprints.findBySlug(p.id, "same");
+  assert.equal(found?.name, "A");
+  assert.equal(await sprints.findBySlug(p.id, "missing"), null);
+});

package/tests/infrastructure/drizzle-task.repository.test.ts

@@ -0,0 +1,132 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Integration tests for DrizzleTaskRepository.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ValidationError } from "../../src/errors/backend-errors.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+async function seedPlanWithTwoSprints(db: Awaited<ReturnType<typeof createTestDb>>) {
+  const { plans, sprints } = createRepositories("sqlite", { sqlite: { db } });
+  const plan = await plans.create({ slug: "p", title: "P" });
+  const sa = await sprints.create({
+    slug: "a",
+    planId: plan.id,
+    name: "A",
+    goal: "G"
+  });
+  const sb = await sprints.create({
+    slug: "b",
+    planId: plan.id,
+    name: "B",
+    goal: "G"
+  });
+  return { plan, sa, sb };
+}
+
+test("create rejects duplicate order in same sprint", async () => {
+  const db = await createTestDb();
+  const { sa } = await seedPlanWithTwoSprints(db);
+  const { tasks } = createRepositories("sqlite", { sqlite: { db } });
+  await tasks.create({
+    sprintId: sa.id,
+    title: "T0",
+    priority: "low",
+    order: 0
+  });
+  await assert.rejects(
+    () =>
+      tasks.create({
+        sprintId: sa.id,
+        title: "T1",
+        priority: "low",
+        order: 0
+      }),
+    ValidationError
+  );
+});
+
+test("move assigns next order in target sprint", async () => {
+  const db = await createTestDb();
+  const { sa, sb } = await seedPlanWithTwoSprints(db);
+  const { tasks } = createRepositories("sqlite", { sqlite: { db } });
+  const t = await tasks.create({
+    sprintId: sa.id,
+    title: "Move me",
+    priority: "high"
+  });
+  await tasks.create({
+    sprintId: sb.id,
+    title: "Existing",
+    priority: "medium"
+  });
+  const moved = await tasks.move(t.id, sb.id);
+  assert.equal(moved?.sprintId, sb.id);
+  assert.ok(moved && moved.order >= 1);
+});
+
+test("listDependentTaskIds returns tasks that depend on a prerequisite", async () => {
+  const db = await createTestDb();
+  const { sa } = await seedPlanWithTwoSprints(db);
+  const { tasks } = createRepositories("sqlite", { sqlite: { db } });
+  const t1 = await tasks.create({
+    sprintId: sa.id,
+    title: "Prereq",
+    priority: "medium"
+  });
+  const t2 = await tasks.create({
+    sprintId: sa.id,
+    title: "Dependent",
+    priority: "medium"
+  });
+  await tasks.setDependencies(t2.id, [t1.id]);
+  const ids = await tasks.listDependentTaskIds(t1.id);
+  assert.deepEqual(ids.sort(), [t2.id].sort());
+  assert.equal((await tasks.listDependentTaskIds(t2.id)).length, 0);
+});
+
+test("setDependencies and getDependencies round-trip", async () => {
+  const db = await createTestDb();
+  const { sa } = await seedPlanWithTwoSprints(db);
+  const { tasks } = createRepositories("sqlite", { sqlite: { db } });
+  const t1 = await tasks.create({
+    sprintId: sa.id,
+    title: "T1",
+    priority: "medium"
+  });
+  const t2 = await tasks.create({
+    sprintId: sa.id,
+    title: "T2",
+    priority: "medium"
+  });
+  await tasks.setDependencies(t1.id, [t2.id]);
+  const deps = await tasks.getDependencies(t1.id);
+  assert.equal(deps.length, 1);
+  assert.equal(deps[0]?.dependsOnTaskId, t2.id);
+  await tasks.setDependencies(t1.id, []);
+  assert.equal((await tasks.getDependencies(t1.id)).length, 0);
+});
+
+test("listByPlanId returns tasks across sprints with optional filter", async () => {
+  const db = await createTestDb();
+  const { plan, sa, sb } = await seedPlanWithTwoSprints(db);
+  const { tasks } = createRepositories("sqlite", { sqlite: { db } });
+  await tasks.create({
+    sprintId: sa.id,
+    title: "Todo A",
+    priority: "low"
+  });
+  await tasks.create({
+    sprintId: sb.id,
+    title: "Done B",
+    priority: "high"
+  });
+  const u = await tasks.listByPlanId(plan.id);
+  assert.equal(u.length, 2);
+  const highs = await tasks.listByPlanId(plan.id, { priority: "high" });
+  assert.equal(highs.length, 1);
+  assert.equal(highs[0]?.title, "Done B");
+});

package/tests/mcp/mcp-text-formatters.test.ts

@@ -0,0 +1,246 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Unit tests for MCP agent-facing text formatters.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { Plan } from "../../src/domain/entities/plan.entity";
+import type { Sprint } from "../../src/domain/entities/sprint.entity";
+import type { Task, TaskStatus } from "../../src/domain/entities/task.entity";
+import {
+  formatExecutionContext,
+  formatPlanList,
+  formatPlanSummary,
+  formatSprintDetail,
+  formatSprintList,
+  formatTaskList,
+  shortId,
+  type SprintWithTaskCounts
+} from "../../src/mcp/mcp-text-formatters.js";
+
+const samplePlan = (over: Partial<Plan> = {}): Plan => ({
+  id: "11111111-1111-4111-8111-111111111111",
+  slug: "my-plan",
+  title: "My Project Plan",
+  description: null,
+  markdownContent: null,
+  status: "active",
+  isActive: true,
+  createdAt: "",
+  updatedAt: "",
+  ...over
+});
+
+const sampleSprint = (over: Partial<Sprint> = {}): Sprint => ({
+  id: "22222222-2222-4222-8222-222222222222",
+  slug: "sprint-1",
+  planId: "11111111-1111-4111-8111-111111111111",
+  name: "Sprint 1",
+  goal: "Ship",
+  markdownContent: null,
+  status: "active",
+  order: 0,
+  startDate: null,
+  endDate: null,
+  createdAt: "",
+  updatedAt: "",
+  ...over
+});
+
+const sampleTask = (over: Partial<Task> = {}): Task => ({
+  id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+  sprintId: "22222222-2222-4222-8222-222222222222",
+  title: "Set up CI pipeline",
+  description: null,
+  status: "todo",
+  priority: "high",
+  order: 0,
+  assignee: "vikash",
+  tags: null,
+  touchedFiles: [],
+  createdAt: "",
+  updatedAt: "",
+  ...over
+});
+
+test("shortId returns first 8 hex chars without dashes", () => {
+  assert.equal(
+    shortId("aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"),
+    "aaaaaaaa"
+  );
+});
+
+test("formatPlanList includes slug, status, title, and active marker", () => {
+  const active = samplePlan({
+    slug: "my-plan",
+    title: "My Project Plan",
+    status: "active",
+    isActive: true
+  });
+  const archived = samplePlan({
+    id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+    slug: "old-plan",
+    title: "Old Plan",
+    status: "archived",
+    isActive: false
+  });
+  const text = formatPlanList([active, archived], active.id);
+  assert.ok(text.includes("Plans (2):"));
+  assert.ok(
+    text.includes(
+      '- my-plan [active] "My Project Plan" (active plan)'
+    )
+  );
+  assert.ok(text.includes('- old-plan [archived] "Old Plan"'));
+});
+
+test("formatSprintList includes task count breakdown per sprint", () => {
+  const sprints: SprintWithTaskCounts[] = [
+    {
+      ...sampleSprint({ slug: "sprint-1", name: "Sprint 1", status: "active" }),
+      taskCounts: counts(2, 1, 0, 0)
+    },
+    {
+      ...sampleSprint({
+        id: "33333333-3333-4333-8333-333333333333",
+        slug: "sprint-2",
+        name: "Sprint 2",
+        status: "planned"
+      }),
+      taskCounts: counts(3, 0, 0, 0)
+    }
+  ];
+  const text = formatSprintList("my-plan", sprints);
+  assert.ok(text.includes("Sprints for 'my-plan' (2):"));
+  assert.ok(text.includes("sprint-1 [active]"));
+  assert.ok(text.includes("2 todo, 1 in_progress"));
+  assert.ok(text.includes("sprint-2 [planned]"));
+  assert.ok(text.includes("3 todo"));
+  assert.ok(text.includes("sprintId:22222222-2222-4222-8222-222222222222"));
+  assert.ok(text.includes("sprintId:33333333-3333-4333-8333-333333333333"));
+});
+
+test("formatTaskList includes status, title, priority, assignee, short id", () => {
+  const tasks = [
+    sampleTask({
+      title: "Set up CI pipeline",
+      status: "todo",
+      priority: "high",
+      assignee: "vikash"
+    }),
+    sampleTask({
+      id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+      title: "Write unit tests",
+      status: "in_progress",
+      priority: "medium",
+      assignee: null
+    })
+  ];
+  const text = formatTaskList(tasks);
+  assert.ok(text.includes("Tasks (2):"));
+  assert.ok(
+    text.includes('[todo] "Set up CI pipeline"') &&
+      text.includes("priority: high") &&
+      text.includes("assignee: vikash")
+  );
+  assert.ok(text.includes('[in_progress] "Write unit tests"'));
+  assert.ok(text.includes(`id:${shortId(tasks[0]!.id)}`));
+});
+
+test("formatPlanSummary includes sprint breakdown and short ids", () => {
+  const plan = samplePlan();
+  const sprintsOut = [
+    {
+      sprintSlug: "sprint-1",
+      sprintId: "22222222-2222-4222-8222-222222222222",
+      name: "Sprint 1",
+      status: "active" as const,
+      taskCounts: counts(2, 3, 0, 1)
+    },
+    {
+      sprintSlug: "backlog",
+      sprintId: "33333333-3333-4333-8333-333333333333",
+      name: "Backlog",
+      status: "planned" as const,
+      taskCounts: counts(1, 0, 0, 0)
+    }
+  ];
+  const text = formatPlanSummary(plan, sprintsOut);
+  assert.ok(text.includes(`Plan 'my-plan' ("My Project Plan")`));
+  assert.ok(text.includes("7 tasks total"));
+  assert.ok(text.includes("Sprint breakdown:"));
+  assert.ok(text.includes("sprint-1 [active]:"));
+  assert.ok(text.includes("2 todo, 3 in_progress, 1 done"));
+  assert.ok(text.includes("id: 22222222"));
+});
+
+test("formatExecutionContext lists tasks under each active sprint", () => {
+  const plan = samplePlan();
+  const sprint = sampleSprint();
+  const tasks = [
+    sampleTask({ title: "Task A", status: "todo", priority: "high" }),
+    sampleTask({
+      id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb",
+      title: "Task B",
+      status: "in_progress",
+      priority: "medium",
+      assignee: "vikash"
+    })
+  ];
+  const text = formatExecutionContext(plan.slug, [
+    {
+      sprintSlug: sprint.slug,
+      sprint,
+      tasks,
+      taskCounts: countFromTasks(tasks)
+    }
+  ]);
+  assert.ok(text.includes("Execution context for 'my-plan':"));
+  assert.ok(text.includes("Active sprints (1):"));
+  assert.ok(text.includes(`Sprint 'sprint-1'`));
+  assert.ok(text.includes('"Task A"'));
+  assert.ok(text.includes('"Task B"'));
+  assert.ok(text.includes("Summary: 1 todo, 1 in_progress"));
+});
+
+test("formatSprintDetail includes metadata and task lines", () => {
+  const sprint = sampleSprint({
+    goal: "Finish MVP",
+    startDate: "2025-01-01T00:00:00.000Z",
+    endDate: "2025-01-31T00:00:00.000Z"
+  });
+  const tasks = [sampleTask({ title: "Only task" })];
+  const text = formatSprintDetail(sprint, tasks);
+  assert.ok(text.includes("Sprint 'Sprint 1' (sprint-1) [active]"));
+  assert.ok(text.includes("Goal: Finish MVP"));
+  assert.ok(text.includes("Tasks (1):"));
+  assert.ok(text.includes('"Only task"'));
+});
+
+test("formatSprintDetail appends markdown section when markdownContent is set", () => {
+  const sprint = sampleSprint({
+    markdownContent: "## Notes\nHello."
+  });
+  const text = formatSprintDetail(sprint, []);
+  assert.ok(text.includes("--- Markdown ---"));
+  assert.ok(text.includes("## Notes"));
+  assert.ok(text.includes("Hello."));
+});
+
+function counts(
+  todo: number,
+  in_progress: number,
+  blocked: number,
+  done: number
+): Record<TaskStatus, number> {
+  return { todo, in_progress, blocked, done };
+}
+
+function countFromTasks(ts: Task[]): Record<TaskStatus, number> {
+  const base = counts(0, 0, 0, 0);
+  for (const t of ts) {
+    base[t.status] += 1;
+  }
+  return base;
+}

package/tests/mcp/register-sprintdock-mcp-tools.test.ts

@@ -0,0 +1,207 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Smoke tests for MCP tool registration (sql.js DB + private SDK registry shape).
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createApplicationServices } from "../../src/application/container.js";
+import { ConsoleAuditLog } from "../../src/infrastructure/observability/audit-log.js";
+import { RequestCorrelation } from "../../src/infrastructure/observability/request-correlation.js";
+import { LocalAuthContextResolver } from "../../src/infrastructure/security/auth-context.js";
+import { InMemoryBackendRateLimiter } from "../../src/infrastructure/security/rate-limiter.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { z } from "zod";
+import {
+  defaultSprintdockMcpPlugins,
+  registerSprintdockMcpTools
+} from "../../src/mcp/register-sprintdock-mcp-tools.js";
+import type { SprintdockMcpToolPlugin } from "../../src/mcp/plugins/types.js";
+import { SPRINTDOCK_MCP_CAPABILITIES } from "../../src/mcp/sprintdock-mcp-capabilities.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+const EXPECTED_TOOL_NAMES = [
+  "assign_task",
+  "bulk_create_tasks",
+  "bulk_update_task_status",
+  "create_plan",
+  "create_sprint",
+  "create_task",
+  "delete_plan",
+  "delete_sprint",
+  "delete_task",
+  "get_active_plan",
+  "get_execution_context",
+  "get_plan_progress",
+  "get_plan_summary",
+  "get_sprint",
+  "get_sprint_detail",
+  "get_task",
+  "get_task_dependencies",
+  "list_plans",
+  "list_sprints",
+  "list_tasks",
+  "move_task",
+  "set_active_plan",
+  "update_plan",
+  "update_plan_markdown",
+  "update_sprint",
+  "update_sprint_markdown",
+  "update_sprint_status",
+  "update_task",
+  "update_task_dependencies",
+  "update_task_status"
+] as const;
+
+type RegisteredToolEntry = {
+  handler: (args: Record<string, unknown>) => Promise<unknown>;
+};
+
+function getToolRegistry(server: McpServer): Record<string, RegisteredToolEntry> {
+  return (server as unknown as { _registeredTools: Record<string, RegisteredToolEntry> })
+    ._registeredTools;
+}
+
+function toolEntry(
+  registry: Record<string, RegisteredToolEntry>,
+  name: (typeof EXPECTED_TOOL_NAMES)[number]
+): RegisteredToolEntry {
+  const t = registry[name];
+  if (!t) {
+    throw new Error(`Missing registered tool: ${name}`);
+  }
+  return t;
+}
+
+async function makeMcpWithTools(): Promise<{ server: McpServer; tools: Record<string, RegisteredToolEntry> }> {
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const services = createApplicationServices(repos);
+  const server = new McpServer(
+    { name: "sprintdock-backend-test", version: "0.0.0-test" },
+    {
+      capabilities: SPRINTDOCK_MCP_CAPABILITIES,
+      instructions: "test"
+    }
+  );
+  registerSprintdockMcpTools(server, {
+    services,
+    auditLog: new ConsoleAuditLog(),
+    rateLimiter: new InMemoryBackendRateLimiter(),
+    requestCorrelation: new RequestCorrelation(),
+    authContextResolver: new LocalAuthContextResolver()
+  });
+  return { server, tools: getToolRegistry(server) };
+}
+
+test("registers 30 Sprintdock MCP tools", async () => {
+  const { tools } = await makeMcpWithTools();
+  const names = Object.keys(tools).sort();
+  assert.deepEqual(names, [...EXPECTED_TOOL_NAMES].sort());
+});
+
+test("list_plans returns empty plans on fresh DB", async () => {
+  const { tools } = await makeMcpWithTools();
+  const result = (await toolEntry(tools, "list_plans").handler({})) as {
+    content?: { type: string; text: string }[];
+    structuredContent?: { plans?: unknown[]; total?: number };
+  };
+  assert.ok(Array.isArray(result.structuredContent?.plans));
+  assert.equal(result.structuredContent?.plans?.length, 0);
+  assert.equal(result.structuredContent?.total, 0);
+  const text = result.content?.[0]?.text ?? "";
+  assert.ok(text.includes("Plans (0):"));
+});
+
+test("optional plugins append custom tools after defaults", async () => {
+  const customPlugin: SprintdockMcpToolPlugin = {
+    id: "test/custom-ping",
+    register(server) {
+      server.registerTool(
+        "demo_ping",
+        {
+          description: "Test-only ping tool.",
+          inputSchema: z.object({}).strict()
+        },
+        async () => ({
+          content: [{ type: "text", text: "pong" }]
+        })
+      );
+    }
+  };
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const services = createApplicationServices(repos);
+  const server = new McpServer(
+    { name: "sprintdock-plugin-test", version: "0.0.0-test" },
+    {
+      capabilities: SPRINTDOCK_MCP_CAPABILITIES,
+      instructions: "test"
+    }
+  );
+  registerSprintdockMcpTools(server, {
+    services,
+    auditLog: new ConsoleAuditLog(),
+    rateLimiter: new InMemoryBackendRateLimiter(),
+    requestCorrelation: new RequestCorrelation(),
+    authContextResolver: new LocalAuthContextResolver()
+  }, {
+    plugins: [...defaultSprintdockMcpPlugins, customPlugin]
+  });
+  const tools = getToolRegistry(server);
+  assert.ok(tools["demo_ping"]);
+  const ping = (await tools["demo_ping"]!.handler({})) as {
+    content?: { text: string }[];
+  };
+  assert.equal(ping.content?.[0]?.text, "pong");
+});
+
+test("create_plan then list_plans sees the plan", async () => {
+  const { tools } = await makeMcpWithTools();
+  await toolEntry(tools, "create_plan").handler({
+    planSlug: "alpha-plan",
+    title: "Alpha"
+  });
+  const result = (await toolEntry(tools, "list_plans").handler({})) as {
+    content?: { type: string; text: string }[];
+    structuredContent?: { plans?: { slug: string }[]; total?: number };
+  };
+  assert.equal(result.structuredContent?.plans?.length, 1);
+  assert.equal(result.structuredContent?.plans?.[0]?.slug, "alpha-plan");
+  assert.equal(result.structuredContent?.total, 1);
+  const text = result.content?.[0]?.text ?? "";
+  assert.ok(text.includes("alpha-plan"));
+  assert.ok(text.includes("Alpha"));
+  assert.ok(text.includes("(active plan)"));
+});
+
+test("create_task and bulk_create_tasks accept sprint slug via sprintIdOrSlug", async () => {
+  const { tools } = await makeMcpWithTools();
+  await toolEntry(tools, "create_plan").handler({
+    planSlug: "slug-plan",
+    title: "Slug Plan"
+  });
+  await toolEntry(tools, "create_sprint").handler({
+    planSlug: "slug-plan",
+    sprintSlug: "s1",
+    name: "Sprint One",
+    goal: "Goal"
+  });
+  const one = (await toolEntry(tools, "create_task").handler({
+    planSlug: "slug-plan",
+    sprintIdOrSlug: "s1",
+    title: "Task A",
+    description: ""
+  })) as { structuredContent?: { title: string; sprintId: string } };
+  assert.equal(one.structuredContent?.title, "Task A");
+  assert.ok(one.structuredContent?.sprintId);
+
+  const bulk = (await toolEntry(tools, "bulk_create_tasks").handler({
+    planSlug: "slug-plan",
+    sprintIdOrSlug: "s1",
+    tasks: [{ title: "B" }, { title: "C" }]
+  })) as { structuredContent?: { tasks?: { title: string }[] } };
+  assert.equal(bulk.structuredContent?.tasks?.length, 2);
+  assert.equal(bulk.structuredContent?.tasks?.[0]?.title, "B");
+});