@dailephd/my-dev-kit-lab 0.2.0

package/benchmarks/projects/task-analytics-large-mixed/ts/src/services/completeTask.ts

@@ -0,0 +1,10 @@
+import type { AnalyticsTask } from "../models/task.js";
+import { AnalyticsTaskStore } from "../store/taskStore.js";
+
+export function completeTask(taskStore: AnalyticsTaskStore, taskId: string, updatedDay: number): AnalyticsTask {
+  return taskStore.update(taskId, (task) => ({
+    ...task,
+    completed: true,
+    updatedDay
+  }));
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/services/createTask.ts

@@ -0,0 +1,21 @@
+import type { AnalyticsTask } from "../models/task.js";
+import { ProjectStore } from "../store/projectStore.js";
+import { AnalyticsTaskStore } from "../store/taskStore.js";
+import { assertKnownProject } from "../validation/projectValidation.js";
+import { normalizeLabels, validateStoryPoints, validateTaskTitle } from "../validation/taskValidation.js";
+
+export function createTask(
+  taskStore: AnalyticsTaskStore,
+  projectStore: ProjectStore,
+  input: Omit<AnalyticsTask, "id" | "completed"> & { completed?: boolean }
+): AnalyticsTask {
+  return taskStore.create({
+    title: validateTaskTitle(input.title),
+    projectId: assertKnownProject(projectStore, input.projectId),
+    assignee: input.assignee.trim(),
+    completed: input.completed ?? false,
+    storyPoints: validateStoryPoints(input.storyPoints),
+    updatedDay: input.updatedDay,
+    labels: normalizeLabels(input.labels)
+  });
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/services/listTasksByProject.ts

@@ -0,0 +1,6 @@
+import type { AnalyticsTask } from "../models/task.js";
+import { AnalyticsTaskStore } from "../store/taskStore.js";
+
+export function listTasksByProject(taskStore: AnalyticsTaskStore, projectId: string): AnalyticsTask[] {
+  return taskStore.list().filter((task) => task.projectId === projectId);
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/store/projectStore.ts

@@ -0,0 +1,20 @@
+import type { AnalyticsProject } from "../models/project.js";
+
+export class ProjectStore {
+  private readonly projects = new Map<string, AnalyticsProject>();
+
+  constructor(seed: AnalyticsProject[] = []) {
+    for (const project of seed) {
+      this.projects.set(project.id, { ...project });
+    }
+  }
+
+  list(): AnalyticsProject[] {
+    return [...this.projects.values()].map((project) => ({ ...project }));
+  }
+
+  get(projectId: string): AnalyticsProject | undefined {
+    const project = this.projects.get(projectId);
+    return project ? { ...project } : undefined;
+  }
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/store/taskStore.ts

@@ -0,0 +1,44 @@
+import type { AnalyticsTask } from "../models/task.js";
+
+export class AnalyticsTaskStore {
+  private nextSequence = 1;
+  private readonly tasks = new Map<string, AnalyticsTask>();
+
+  constructor(seed: AnalyticsTask[] = []) {
+    for (const task of seed) {
+      this.tasks.set(task.id, { ...task, labels: [...task.labels] });
+      this.nextSequence = Math.max(this.nextSequence, sequenceFromId(task.id) + 1);
+    }
+  }
+
+  create(input: Omit<AnalyticsTask, "id">): AnalyticsTask {
+    const task: AnalyticsTask = {
+      ...input,
+      id: `task-${this.nextSequence++}`,
+      labels: [...input.labels]
+    };
+    this.tasks.set(task.id, task);
+    return { ...task, labels: [...task.labels] };
+  }
+
+  update(taskId: string, updater: (task: AnalyticsTask) => AnalyticsTask): AnalyticsTask {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Unknown task id: ${taskId}`);
+    }
+    const updated = updater({ ...task, labels: [...task.labels] });
+    this.tasks.set(taskId, { ...updated, labels: [...updated.labels] });
+    return { ...updated, labels: [...updated.labels] };
+  }
+
+  list(): AnalyticsTask[] {
+    return [...this.tasks.values()]
+      .map((task) => ({ ...task, labels: [...task.labels] }))
+      .sort((left, right) => left.id.localeCompare(right.id));
+  }
+}
+
+function sequenceFromId(id: string): number {
+  const match = id.match(/-(\d+)$/);
+  return match ? Number(match[1]) : 0;
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/validation/projectValidation.ts

@@ -0,0 +1,12 @@
+import { ProjectStore } from "../store/projectStore.js";
+
+export function assertKnownProject(projectStore: ProjectStore, projectId: string): string {
+  const normalized = projectId.trim();
+  if (!normalized) {
+    throw new Error("projectId must not be empty.");
+  }
+  if (!projectStore.get(normalized)) {
+    throw new Error(`Unknown project id: ${normalized}`);
+  }
+  return normalized;
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/validation/taskValidation.ts

@@ -0,0 +1,18 @@
+export function validateTaskTitle(title: string): string {
+  const normalized = title.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    throw new Error("Task title must not be empty.");
+  }
+  return normalized;
+}
+
+export function validateStoryPoints(storyPoints: number): number {
+  if (!Number.isInteger(storyPoints) || storyPoints < 1 || storyPoints > 13) {
+    throw new Error("storyPoints must be an integer between 1 and 13.");
+  }
+  return storyPoints;
+}
+
+export function normalizeLabels(labels: string[]): string[] {
+  return [...new Set(labels.map((label) => label.trim().toLowerCase()).filter(Boolean))].sort();
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/tests/buildAnalyticsSnapshot.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { buildAnalyticsSnapshot } from "../src/services/buildAnalyticsSnapshot.js";
+import { ProjectStore } from "../src/store/projectStore.js";
+import { AnalyticsTaskStore } from "../src/store/taskStore.js";
+import { completeTask } from "../src/services/completeTask.js";
+import { createTask } from "../src/services/createTask.js";
+
+describe("buildAnalyticsSnapshot", () => {
+  it("computes per-project totals, completion rate, and stale counts", () => {
+    const projectStore = new ProjectStore([
+      { id: "alpha", name: "Alpha", owner: "Ada" },
+      { id: "beta", name: "Beta", owner: "Bo" }
+    ]);
+    const taskStore = new AnalyticsTaskStore();
+    const done = createTask(taskStore, projectStore, {
+      title: "Ship metrics",
+      projectId: "alpha",
+      assignee: "Lee",
+      storyPoints: 5,
+      updatedDay: 2,
+      labels: []
+    });
+    createTask(taskStore, projectStore, {
+      title: "Audit backlog",
+      projectId: "alpha",
+      assignee: "Sam",
+      storyPoints: 3,
+      updatedDay: 1,
+      labels: ["ops"]
+    });
+    createTask(taskStore, projectStore, {
+      title: "Tune report",
+      projectId: "beta",
+      assignee: "Ira",
+      storyPoints: 8,
+      updatedDay: 11,
+      labels: ["report"]
+    });
+    completeTask(taskStore, done.id, 8);
+    expect(buildAnalyticsSnapshot(taskStore, projectStore, 15)).toMatchObject({
+      totals: { totalTasks: 3, completedTasks: 1, openTasks: 2, staleTasks: 1 },
+      projects: [
+        { projectId: "alpha", totalTasks: 2, completedTasks: 1, openTasks: 1, staleTasks: 1, completionRate: 50 },
+        { projectId: "beta", totalTasks: 1, completedTasks: 0, openTasks: 1, staleTasks: 0, completionRate: 0 }
+      ]
+    });
+  });
+});

package/benchmarks/projects/task-analytics-large-mixed/ts/tests/completeTask.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { ProjectStore } from "../src/store/projectStore.js";
+import { AnalyticsTaskStore } from "../src/store/taskStore.js";
+import { completeTask } from "../src/services/completeTask.js";
+import { createTask } from "../src/services/createTask.js";
+
+describe("completeTask", () => {
+  it("marks a selected task completed and updates its day marker", () => {
+    const projectStore = new ProjectStore([{ id: "alpha", name: "Alpha", owner: "Ada" }]);
+    const taskStore = new AnalyticsTaskStore();
+    const created = createTask(taskStore, projectStore, {
+      title: "Ship metrics",
+      projectId: "alpha",
+      assignee: "Lee",
+      storyPoints: 5,
+      updatedDay: 2,
+      labels: []
+    });
+    expect(completeTask(taskStore, created.id, 9)).toMatchObject({ completed: true, updatedDay: 9 });
+  });
+});

package/benchmarks/projects/task-analytics-large-mixed/ts/tests/createTask.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { ProjectStore } from "../src/store/projectStore.js";
+import { AnalyticsTaskStore } from "../src/store/taskStore.js";
+import { createTask } from "../src/services/createTask.js";
+
+describe("createTask", () => {
+  it("creates deterministic ids and validates projects", () => {
+    const projectStore = new ProjectStore([{ id: "alpha", name: "Alpha", owner: "Ada" }]);
+    const taskStore = new AnalyticsTaskStore();
+    expect(
+      createTask(taskStore, projectStore, {
+        title: "Ship metrics",
+        projectId: "alpha",
+        assignee: "Lee",
+        storyPoints: 5,
+        updatedDay: 2,
+        labels: ["Metrics"]
+      }).id
+    ).toBe("task-1");
+    expect(() =>
+      createTask(taskStore, projectStore, {
+        title: "Ship metrics",
+        projectId: "missing",
+        assignee: "Lee",
+        storyPoints: 5,
+        updatedDay: 2,
+        labels: []
+      })
+    ).toThrow("Unknown project id: missing");
+  });
+});

package/benchmarks/projects/task-analytics-large-mixed/ts/tests/listTasksByProject.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { ProjectStore } from "../src/store/projectStore.js";
+import { AnalyticsTaskStore } from "../src/store/taskStore.js";
+import { createTask } from "../src/services/createTask.js";
+import { listTasksByProject } from "../src/services/listTasksByProject.js";
+
+describe("listTasksByProject", () => {
+  it("returns only tasks for the requested project", () => {
+    const projectStore = new ProjectStore([
+      { id: "alpha", name: "Alpha", owner: "Ada" },
+      { id: "beta", name: "Beta", owner: "Bo" }
+    ]);
+    const taskStore = new AnalyticsTaskStore();
+    createTask(taskStore, projectStore, { title: "One", projectId: "alpha", assignee: "A", storyPoints: 2, updatedDay: 1, labels: [] });
+    createTask(taskStore, projectStore, { title: "Two", projectId: "beta", assignee: "B", storyPoints: 3, updatedDay: 1, labels: [] });
+    expect(listTasksByProject(taskStore, "alpha").map((task) => task.title)).toEqual(["One"]);
+  });
+});

package/benchmarks/projects/task-analytics-large-mixed/ts/tests/reporting.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { buildProjectLeaderboard } from "../src/reporting/buildProjectLeaderboard.js";
+import { formatTaskHealthReport } from "../src/reporting/formatTaskHealthReport.js";
+
+const snapshot = {
+  generatedAt: "2026-03-15T00:00:00.000Z",
+  projects: [
+    { projectId: "alpha", totalTasks: 2, completedTasks: 2, openTasks: 0, staleTasks: 0, averageStoryPoints: 4, completionRate: 100 },
+    { projectId: "beta", totalTasks: 2, completedTasks: 1, openTasks: 1, staleTasks: 1, averageStoryPoints: 5, completionRate: 50 }
+  ],
+  totals: { totalTasks: 4, completedTasks: 3, openTasks: 1, staleTasks: 1 }
+};
+
+describe("reporting", () => {
+  it("ranks projects and formats a deterministic report", () => {
+    expect(buildProjectLeaderboard(snapshot)).toEqual(["1. alpha (100% complete, 0 stale)", "2. beta (50% complete, 1 stale)"]);
+    expect(formatTaskHealthReport(snapshot)).toContain("Projects: 1. alpha (100% complete, 0 stale) | 2. beta (50% complete, 1 stale)");
+  });
+});

package/benchmarks/projects/task-analytics-large-mixed/ts/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  cacheDir: "../../../../.vitest/task-analytics-large-mixed-ts"
+});

package/benchmarks/projects/task-workflow-medium-ts/README.md

@@ -0,0 +1 @@
+Task workflow benchmark project with multiple services, validation rules, filtering, summarization, and deterministic imports.

package/benchmarks/projects/task-workflow-medium-ts/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "task-workflow-medium-ts-benchmark",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4"
+  }
+}

package/benchmarks/projects/task-workflow-medium-ts/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./models/project.js";
+export * from "./models/task.js";
+export * from "./services/completeTask.js";
+export * from "./services/createTask.js";
+export * from "./services/filterTasks.js";
+export * from "./services/importTasks.js";
+export * from "./services/summarizeTasks.js";
+export * from "./store/taskStore.js";
+export * from "./validation/taskValidation.js";

package/benchmarks/projects/task-workflow-medium-ts/src/models/project.ts

@@ -0,0 +1,6 @@
+export type WorkflowProject = {
+  id: string;
+  name: string;
+  slug: string;
+  archived: boolean;
+};

package/benchmarks/projects/task-workflow-medium-ts/src/models/task.ts

@@ -0,0 +1,39 @@
+export type TaskPriority = "low" | "medium" | "high";
+
+export type WorkflowTask = {
+  id: string;
+  title: string;
+  normalizedTitle: string;
+  projectId: string;
+  priority: TaskPriority;
+  tags: string[];
+  completed: boolean;
+  notes: string;
+  createdAt: string;
+  completedAt?: string;
+  importSource?: string;
+};
+
+export type TaskFilter = {
+  projectId?: string;
+  query?: string;
+  tag?: string;
+  completed?: boolean;
+  priority?: TaskPriority;
+};
+
+export type TaskSummary = {
+  total: number;
+  completed: number;
+  open: number;
+  byProject: Record<string, { total: number; completed: number; open: number }>;
+  highPriorityOpenTitles: string[];
+};
+
+export type TaskImportInput = {
+  title: string;
+  projectId: string;
+  priority?: TaskPriority;
+  tags?: string[];
+  notes?: string;
+};

package/benchmarks/projects/task-workflow-medium-ts/src/services/completeTask.ts

@@ -0,0 +1,15 @@
+import type { WorkflowTask } from "../models/task.js";
+import { TaskWorkflowStore } from "../store/taskStore.js";
+
+export function completeTask(store: TaskWorkflowStore, taskId: string): WorkflowTask {
+  return store.updateTask(taskId, (task) => {
+    if (task.completed) {
+      return task;
+    }
+    return {
+      ...task,
+      completed: true,
+      completedAt: "2026-02-01T00:00:00.000Z"
+    };
+  });
+}

package/benchmarks/projects/task-workflow-medium-ts/src/services/createTask.ts

@@ -0,0 +1,26 @@
+import type { TaskPriority, WorkflowTask } from "../models/task.js";
+import { TaskWorkflowStore } from "../store/taskStore.js";
+import { normalizeTags, validatePriority, validateProjectId, validateTaskTitle } from "../validation/taskValidation.js";
+
+export type CreateTaskInput = {
+  title: string;
+  projectId: string;
+  priority?: TaskPriority;
+  tags?: string[];
+  notes?: string;
+};
+
+export function createTask(store: TaskWorkflowStore, input: CreateTaskInput): WorkflowTask {
+  const title = validateTaskTitle(input.title);
+  const projectId = validateProjectId(input.projectId);
+  if (!store.getProject(projectId)) {
+    throw new Error(`Unknown project id: ${projectId}`);
+  }
+  return store.createTask({
+    title,
+    projectId,
+    priority: validatePriority(input.priority),
+    tags: normalizeTags(input.tags ?? []),
+    notes: input.notes?.trim() ?? ""
+  });
+}

package/benchmarks/projects/task-workflow-medium-ts/src/services/filterTasks.ts

@@ -0,0 +1,17 @@
+import type { TaskFilter, WorkflowTask } from "../models/task.js";
+import { TaskWorkflowStore } from "../store/taskStore.js";
+
+export function filterTasks(store: TaskWorkflowStore, filter: TaskFilter): WorkflowTask[] {
+  const query = filter.query?.trim().toLowerCase();
+  return store.listTasks().filter((task) => {
+    if (filter.projectId && task.projectId !== filter.projectId) return false;
+    if (filter.completed !== undefined && task.completed !== filter.completed) return false;
+    if (filter.priority && task.priority !== filter.priority) return false;
+    if (filter.tag && !task.tags.includes(filter.tag.trim().toLowerCase())) return false;
+    if (query) {
+      const haystack = `${task.title} ${task.notes} ${task.tags.join(" ")}`.toLowerCase();
+      if (!haystack.includes(query)) return false;
+    }
+    return true;
+  });
+}

package/benchmarks/projects/task-workflow-medium-ts/src/services/importTasks.ts

@@ -0,0 +1,33 @@
+import type { TaskImportInput, WorkflowTask } from "../models/task.js";
+import { TaskWorkflowStore } from "../store/taskStore.js";
+import { validateImportInput } from "../validation/taskValidation.js";
+
+export type ImportTasksResult = {
+  imported: WorkflowTask[];
+  skippedDuplicates: string[];
+};
+
+export function importTasks(store: TaskWorkflowStore, items: TaskImportInput[], importSource: string): ImportTasksResult {
+  const imported: WorkflowTask[] = [];
+  const skippedDuplicates: string[] = [];
+
+  for (const item of items) {
+    const validated = validateImportInput(item);
+    if (!store.getProject(validated.projectId)) {
+      throw new Error(`Unknown project id: ${validated.projectId}`);
+    }
+    const duplicate = store.findDuplicate(validated);
+    if (duplicate) {
+      skippedDuplicates.push(duplicate.id);
+      continue;
+    }
+    imported.push(
+      store.createTask({
+        ...validated,
+        importSource
+      })
+    );
+  }
+
+  return { imported, skippedDuplicates };
+}

package/benchmarks/projects/task-workflow-medium-ts/src/services/summarizeTasks.ts

@@ -0,0 +1,30 @@
+import type { TaskSummary } from "../models/task.js";
+import { TaskWorkflowStore } from "../store/taskStore.js";
+
+export function summarizeTasks(store: TaskWorkflowStore): TaskSummary {
+  const tasks = store.listTasks();
+  const byProject: TaskSummary["byProject"] = {};
+
+  for (const project of store.listProjects()) {
+    byProject[project.id] = { total: 0, completed: 0, open: 0 };
+  }
+
+  for (const task of tasks) {
+    byProject[task.projectId] ??= { total: 0, completed: 0, open: 0 };
+    byProject[task.projectId].total += 1;
+    if (task.completed) {
+      byProject[task.projectId].completed += 1;
+    } else {
+      byProject[task.projectId].open += 1;
+    }
+  }
+
+  const completed = tasks.filter((task) => task.completed).length;
+  return {
+    total: tasks.length,
+    completed,
+    open: tasks.length - completed,
+    byProject,
+    highPriorityOpenTitles: tasks.filter((task) => !task.completed && task.priority === "high").map((task) => task.title)
+  };
+}

package/benchmarks/projects/task-workflow-medium-ts/src/store/taskStore.ts

@@ -0,0 +1,76 @@
+import { createDeterministicId } from "../utils/deterministicId.js";
+import type { WorkflowProject } from "../models/project.js";
+import type { TaskImportInput, TaskPriority, WorkflowTask } from "../models/task.js";
+import { normalizeTaskTitle, normalizeTags } from "../validation/taskValidation.js";
+
+export class TaskWorkflowStore {
+  private nextTaskSequence = 1;
+  private readonly projects = new Map<string, WorkflowProject>();
+  private readonly tasks = new Map<string, WorkflowTask>();
+
+  constructor(seed?: { projects?: WorkflowProject[]; tasks?: WorkflowTask[] }) {
+    for (const project of seed?.projects ?? []) {
+      this.projects.set(project.id, { ...project });
+    }
+    for (const task of seed?.tasks ?? []) {
+      this.tasks.set(task.id, { ...task, tags: [...task.tags] });
+      this.nextTaskSequence = Math.max(this.nextTaskSequence, extractSequence(task.id) + 1);
+    }
+  }
+
+  addProject(project: WorkflowProject): void {
+    this.projects.set(project.id, { ...project });
+  }
+
+  getProject(projectId: string): WorkflowProject | undefined {
+    const project = this.projects.get(projectId);
+    return project ? { ...project } : undefined;
+  }
+
+  listProjects(): WorkflowProject[] {
+    return [...this.projects.values()].map((project) => ({ ...project }));
+  }
+
+  createTask(input: { title: string; projectId: string; priority: TaskPriority; tags: string[]; notes: string; importSource?: string }): WorkflowTask {
+    const task: WorkflowTask = {
+      id: createDeterministicId("task", this.nextTaskSequence++),
+      title: input.title,
+      normalizedTitle: normalizeTaskTitle(input.title).toLowerCase(),
+      projectId: input.projectId,
+      priority: input.priority,
+      tags: normalizeTags(input.tags),
+      completed: false,
+      notes: input.notes,
+      createdAt: `2026-01-${String(this.tasks.size + 1).padStart(2, "0")}T00:00:00.000Z`,
+      importSource: input.importSource
+    };
+    this.tasks.set(task.id, task);
+    return { ...task, tags: [...task.tags] };
+  }
+
+  updateTask(id: string, updater: (task: WorkflowTask) => WorkflowTask): WorkflowTask {
+    const existing = this.tasks.get(id);
+    if (!existing) {
+      throw new Error(`Unknown task id: ${id}`);
+    }
+    const updated = updater({ ...existing, tags: [...existing.tags] });
+    this.tasks.set(id, { ...updated, tags: [...updated.tags] });
+    return { ...updated, tags: [...updated.tags] };
+  }
+
+  listTasks(): WorkflowTask[] {
+    return [...this.tasks.values()]
+      .map((task) => ({ ...task, tags: [...task.tags] }))
+      .sort((left, right) => left.id.localeCompare(right.id));
+  }
+
+  findDuplicate(input: TaskImportInput): WorkflowTask | undefined {
+    const normalizedTitle = normalizeTaskTitle(input.title).toLowerCase();
+    return this.listTasks().find((task) => task.projectId === input.projectId && task.normalizedTitle === normalizedTitle);
+  }
+}
+
+function extractSequence(id: string): number {
+  const match = id.match(/-(\d+)$/);
+  return match ? Number(match[1]) : 0;
+}

package/benchmarks/projects/task-workflow-medium-ts/src/utils/deterministicId.ts

@@ -0,0 +1,3 @@
+export function createDeterministicId(prefix: string, sequence: number): string {
+  return `${prefix}-${sequence}`;
+}

package/benchmarks/projects/task-workflow-medium-ts/src/validation/taskValidation.ts

@@ -0,0 +1,45 @@
+import type { TaskImportInput, TaskPriority } from "../models/task.js";
+
+const VALID_PRIORITIES = new Set<TaskPriority>(["low", "medium", "high"]);
+
+export function normalizeTaskTitle(title: string): string {
+  return title.trim().replace(/\s+/g, " ");
+}
+
+export function validateTaskTitle(title: string): string {
+  const normalized = normalizeTaskTitle(title);
+  if (!normalized) {
+    throw new Error("Task title must not be empty.");
+  }
+  return normalized;
+}
+
+export function validateProjectId(projectId: string): string {
+  const normalized = projectId.trim();
+  if (!normalized) {
+    throw new Error("projectId must not be empty.");
+  }
+  return normalized;
+}
+
+export function validatePriority(priority: TaskPriority | undefined): TaskPriority {
+  const resolved = priority ?? "medium";
+  if (!VALID_PRIORITIES.has(resolved)) {
+    throw new Error(`Unsupported priority: ${priority}`);
+  }
+  return resolved;
+}
+
+export function validateImportInput(input: TaskImportInput): Required<TaskImportInput> {
+  return {
+    title: validateTaskTitle(input.title),
+    projectId: validateProjectId(input.projectId),
+    priority: validatePriority(input.priority),
+    tags: normalizeTags(input.tags ?? []),
+    notes: input.notes?.trim() ?? ""
+  };
+}
+
+export function normalizeTags(tags: string[]): string[] {
+  return [...new Set(tags.map((tag) => tag.trim().toLowerCase()).filter(Boolean))].sort();
+}

package/benchmarks/projects/task-workflow-medium-ts/tests/completeTask.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { completeTask } from "../src/services/completeTask.js";
+import { createTask } from "../src/services/createTask.js";
+import { TaskWorkflowStore } from "../src/store/taskStore.js";
+
+describe("completeTask", () => {
+  it("marks only the selected task as completed", () => {
+    const store = new TaskWorkflowStore({
+      projects: [{ id: "alpha", name: "Alpha", slug: "alpha", archived: false }]
+    });
+    const first = createTask(store, { title: "One", projectId: "alpha" });
+    createTask(store, { title: "Two", projectId: "alpha" });
+    expect(completeTask(store, first.id).completed).toBe(true);
+    expect(store.listTasks().map((task) => task.completed)).toEqual([true, false]);
+  });
+});