@dailephd/my-dev-kit-lab 0.2.0

package/benchmarks/contracts/todo-behavior.md

@@ -0,0 +1,70 @@
+# Todo Core Benchmark Behavior
+
+Purpose:
+
+This benchmark defines a small, deterministic Todo Core program used for retrieval, benchmark, and later evaluation workflows in my-dev-kit-lab.
+
+These projects are small by design so they are cheap to index, test, compare, and use in future raw full-file versus retrieved-context experiments.
+
+Shared task shape:
+
+- `id: string`
+- `title: string`
+- `completed: boolean`
+
+Required operations:
+
+- `createTask(title)`
+- `completeTask(id)`
+- `listTasks()`
+- `listOpenTasks()`
+- `summarizeTasks()`
+
+Expected validation behavior:
+
+- `createTask` must reject empty or whitespace-only titles
+- validation failure must raise a clear error
+
+Expected deterministic ID behavior:
+
+- IDs must be deterministic for a fresh in-memory store
+- the first created task must use `task-1`
+- the second created task must use `task-2`
+
+Required test coverage:
+
+- create task
+- complete task
+- list all tasks
+- list open tasks
+- summarize task counts
+- validate empty task title
+- deterministic IDs
+
+Benchmark purpose:
+
+The benchmark exists to keep multiple language layouts behaviorally aligned so later prompts can compare retrieval and evaluation approaches without changing the underlying task semantics.
+
+Project profile metadata:
+
+- project profiles live in `benchmarks/contracts/benchmark-project-profiles.json`
+- every profile names the benchmark project, language mix, primary language, source roots, test roots, compact file tree, benchmark purpose, expected use cases, complexity metrics, complexity score, and scoring formula
+- file-tree entries use relative paths and include source, test, README, package, and config files
+- file-tree entries must exclude generated or external folders such as `node_modules`, `dist`, `build`, `coverage`, `lab-output`, `.git`, and interpreter caches
+
+Project complexity formula:
+
+- `projectComplexityScore` ranges from 0 to 100
+- every value is normalized as `min(value / cap, 1)`
+- formula: `100 * ((0.20 * normalizedSourceFileCount) + (0.20 * normalizedSourceLinesOfCode) + (0.15 * normalizedLanguageCount) + (0.15 * normalizedInternalImportCount) + (0.10 * normalizedMaxFileLines) + (0.10 * normalizedExpectedRelevantFilesAverage) + (0.10 * normalizedExpectedRelevantSymbolsAverage))`
+- caps are `sourceFileCount: 20`, `sourceLinesOfCode: 2000`, `languageCount: 4`, `internalImportCount: 50`, `maxFileLines: 300`, `expectedRelevantFilesAverage: 10`, and `expectedRelevantSymbolsAverage: 20`
+- the final score is rounded to the nearest integer
+
+Answer key requirements:
+
+- every benchmark case must include `answerKey`
+- `answerKey.expectedFiles` lists files a correct answer may need to cite
+- `answerKey.expectedSymbols` lists relevant symbols
+- `answerKey.expectedFacts` lists weighted facts with unique `id`, `text`, `weight`, and `required`
+- `answerKey.minimumCorrectFacts` defines the future scoring threshold, but scoring is not implemented in this prompt
+- optional `forbiddenWrongClaims` records claims that should be penalized by a later correctness scorer

package/benchmarks/contracts/todo-benchmark-case.json

@@ -0,0 +1,227 @@
+[
+  {
+    "id": "todo-create-task",
+    "title": "Create a task with deterministic IDs",
+    "task": "Find the code path that creates a task and assigns its deterministic id.",
+    "query": "create task deterministic id task-1",
+    "expectedOperation": "createTask",
+    "expectedSymbols": ["createTask", "create_task", "TaskService"],
+    "expectedFilesByProject": {
+      "todo-ts": ["src/taskService.ts", "src/taskStore.ts"],
+      "todo-python": ["src/task_service.py", "src/task_store.py"],
+      "todo-js": ["src/taskService.js", "src/taskStore.js"],
+      "todo-mixed-ts-py": ["src/taskCli.ts", "python/task_service.py"]
+    },
+    "answerKey": {
+      "expectedFiles": ["src/taskService.ts", "src/taskStore.ts", "src/task_service.py", "src/task_store.py", "src/taskService.js", "src/taskStore.js", "src/taskCli.ts", "python/task_service.py"],
+      "expectedSymbols": ["createTask", "create_task", "TaskService"],
+      "expectedFacts": [
+        {
+          "id": "create-validates-title",
+          "text": "Task creation validates that the title is not empty or whitespace-only.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "create-deterministic-id",
+          "text": "Task creation assigns deterministic IDs such as task-1 and task-2.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "create-stores-incomplete-task",
+          "text": "A newly created task is stored with completed set to false.",
+          "weight": 1,
+          "required": true
+        }
+      ],
+      "forbiddenWrongClaims": ["Task IDs are random UUIDs.", "New tasks are completed by default."],
+      "minimumCorrectFacts": 2,
+      "notes": "A correct answer must identify deterministic ID assignment and the creation path."
+    },
+    "promptComplexityHint": "single operation with storage side effect",
+    "projectComplexityRelevance": "uses service and store files in single-language projects and boundary files in the mixed project",
+    "rawIncludeGlobs": ["src/**/*", "python/**/*", "tests/**/*"],
+    "notes": "The creation path should be obvious and small across all projects."
+  },
+  {
+    "id": "todo-complete-task",
+    "title": "Complete an existing task",
+    "task": "Locate the code path that completes a task by id.",
+    "query": "complete task by id",
+    "expectedOperation": "completeTask",
+    "expectedSymbols": ["completeTask", "complete_task"],
+    "expectedFilesByProject": {
+      "todo-ts": ["src/taskService.ts"],
+      "todo-python": ["src/task_service.py"],
+      "todo-js": ["src/taskService.js"],
+      "todo-mixed-ts-py": ["python/task_service.py", "src/taskCli.ts"]
+    },
+    "answerKey": {
+      "expectedFiles": ["src/taskService.ts", "src/task_service.py", "src/taskService.js", "python/task_service.py", "src/taskCli.ts"],
+      "expectedSymbols": ["completeTask", "complete_task"],
+      "expectedFacts": [
+        {
+          "id": "complete-finds-by-id",
+          "text": "Completion locates the matching task by id.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "complete-marks-completed",
+          "text": "Completion marks the matching task as completed.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "complete-preserves-other-tasks",
+          "text": "Completion does not mark unrelated tasks as completed.",
+          "weight": 1,
+          "required": false
+        }
+      ],
+      "forbiddenWrongClaims": ["completeTask deletes the task.", "completeTask marks every task as completed."],
+      "minimumCorrectFacts": 2,
+      "notes": "A correct answer must distinguish targeted completion from list or delete behavior."
+    },
+    "promptComplexityHint": "single update operation by identifier",
+    "projectComplexityRelevance": "primarily service logic, with mixed project boundary coverage",
+    "rawIncludeGlobs": ["src/**/*", "python/**/*", "tests/**/*"],
+    "notes": "Completion must flip the completed flag for the targeted task."
+  },
+  {
+    "id": "todo-list-open-tasks",
+    "title": "List open tasks only",
+    "task": "Identify the logic that returns only incomplete tasks.",
+    "query": "list open tasks incomplete tasks",
+    "expectedOperation": "listOpenTasks",
+    "expectedSymbols": ["listOpenTasks", "list_open_tasks"],
+    "expectedFilesByProject": {
+      "todo-ts": ["src/taskService.ts"],
+      "todo-python": ["src/task_service.py"],
+      "todo-js": ["src/taskService.js"],
+      "todo-mixed-ts-py": ["python/task_service.py", "src/taskCli.ts"]
+    },
+    "answerKey": {
+      "expectedFiles": ["src/taskService.ts", "src/task_service.py", "src/taskService.js", "python/task_service.py", "src/taskCli.ts"],
+      "expectedSymbols": ["listOpenTasks", "list_open_tasks"],
+      "expectedFacts": [
+        {
+          "id": "open-filters-incomplete",
+          "text": "Open-task listing returns tasks where completed is false.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "open-separate-from-all",
+          "text": "Open-task listing is separate from list-all task behavior.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "open-preserves-task-shape",
+          "text": "Open-task listing returns task objects with id, title, and completed fields.",
+          "weight": 1,
+          "required": false
+        }
+      ],
+      "forbiddenWrongClaims": ["listOpenTasks returns completed tasks only.", "listOpenTasks mutates task completion state."],
+      "minimumCorrectFacts": 2,
+      "notes": "A correct answer must identify filtering on incomplete tasks."
+    },
+    "promptComplexityHint": "read-only filtered list operation",
+    "projectComplexityRelevance": "service-level filter with no storage mutation",
+    "rawIncludeGlobs": ["src/**/*", "python/**/*", "tests/**/*"],
+    "notes": "Open-task listing should remain separate from list-all behavior."
+  },
+  {
+    "id": "todo-summarize-tasks",
+    "title": "Summarize task counts",
+    "task": "Find the summary logic that reports total, open, and completed counts.",
+    "query": "summarize tasks total open completed",
+    "expectedOperation": "summarizeTasks",
+    "expectedSymbols": ["summarizeTasks", "summarize_tasks"],
+    "expectedFilesByProject": {
+      "todo-ts": ["src/taskService.ts"],
+      "todo-python": ["src/task_service.py"],
+      "todo-js": ["src/taskService.js"],
+      "todo-mixed-ts-py": ["python/task_service.py", "src/taskCli.ts"]
+    },
+    "answerKey": {
+      "expectedFiles": ["src/taskService.ts", "src/task_service.py", "src/taskService.js", "python/task_service.py", "src/taskCli.ts"],
+      "expectedSymbols": ["summarizeTasks", "summarize_tasks"],
+      "expectedFacts": [
+        {
+          "id": "summary-total",
+          "text": "Task summary reports the total task count.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "summary-open",
+          "text": "Task summary reports the open task count.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "summary-completed",
+          "text": "Task summary reports the completed task count.",
+          "weight": 1,
+          "required": true
+        }
+      ],
+      "forbiddenWrongClaims": ["Summary returns only a string.", "Summary omits completed tasks."],
+      "minimumCorrectFacts": 3,
+      "notes": "A correct answer must identify the total, open, and completed fields."
+    },
+    "promptComplexityHint": "aggregate read operation",
+    "projectComplexityRelevance": "tests aggregation logic across single-language and mixed-language projects",
+    "rawIncludeGlobs": ["src/**/*", "python/**/*", "tests/**/*"],
+    "notes": "Summary shape must stay aligned across every benchmark project."
+  },
+  {
+    "id": "todo-empty-title-validation",
+    "title": "Reject an empty task title",
+    "task": "Locate the validation that rejects blank task titles.",
+    "query": "empty title validation create task blank title",
+    "expectedOperation": "createTask",
+    "expectedSymbols": ["createTask", "create_task", "validate"],
+    "expectedFilesByProject": {
+      "todo-ts": ["src/taskService.ts"],
+      "todo-python": ["src/task_service.py"],
+      "todo-js": ["src/taskService.js"],
+      "todo-mixed-ts-py": ["python/task_service.py", "src/taskCli.ts"]
+    },
+    "answerKey": {
+      "expectedFiles": ["src/taskService.ts", "src/task_service.py", "src/taskService.js", "python/task_service.py", "src/taskCli.ts"],
+      "expectedSymbols": ["createTask", "create_task", "validate"],
+      "expectedFacts": [
+        {
+          "id": "empty-title-trim",
+          "text": "Title validation rejects empty or whitespace-only task titles.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "empty-title-create-path",
+          "text": "Title validation is part of the create task path.",
+          "weight": 1,
+          "required": true
+        },
+        {
+          "id": "empty-title-error",
+          "text": "Invalid titles produce a clear deterministic error instead of creating a task.",
+          "weight": 1,
+          "required": true
+        }
+      ],
+      "forbiddenWrongClaims": ["Blank titles are silently converted to Untitled.", "Validation happens only in tests."],
+      "minimumCorrectFacts": 2,
+      "notes": "A correct answer must locate validation and explain the rejected blank title behavior."
+    },
+    "promptComplexityHint": "validation behavior inside create operation",
+    "projectComplexityRelevance": "requires reading creation logic rather than only public exports",
+    "rawIncludeGlobs": ["src/**/*", "python/**/*", "tests/**/*"],
+    "notes": "Validation errors should be clear and deterministic."
+  }
+]

package/benchmarks/projects/README.md

@@ -0,0 +1,34 @@
+# Benchmark Projects
+
+This directory contains deterministic benchmark projects used by my-dev-kit-lab.
+
+The current suite mixes baseline Todo fixtures with more complex workflow and analytics projects:
+
+- `todo-ts`
+- `todo-js`
+- `todo-python`
+- `todo-mixed-ts-py`
+- `task-workflow-medium-ts`
+- `task-analytics-large-mixed`
+
+The Todo fixtures stay intentionally small so validation and smoke experiments remain cheap. The newer medium and large projects are intentionally more connected so raw full-file context and guided retrieval diverge more meaningfully.
+
+Benchmark project profiles live in `benchmarks/contracts/benchmark-project-profiles.json`.
+
+Each profile records:
+
+- project identity and description
+- language mix and primary language
+- source roots and test roots
+- deterministic file-tree metadata
+- complexity metrics and complexity score
+- benchmark purpose and expected use cases
+
+Current complexity levels:
+
+- `todo-ts`: small
+- `todo-js`: small
+- `todo-python`: small
+- `todo-mixed-ts-py`: mixed-language
+- `task-workflow-medium-ts`: medium
+- `task-analytics-large-mixed`: large

package/benchmarks/projects/task-analytics-large-mixed/README.md

@@ -0,0 +1 @@
+Mixed TypeScript and Python benchmark project for deterministic task analytics, quality labeling, and report generation.

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/__init__.py

@@ -0,0 +1,3 @@
+from .metrics import calculate_project_metrics
+from .quality import determine_quality_label
+from .reporting import build_health_report

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/fixtures.py

@@ -0,0 +1,6 @@
+def sample_rows():
+    return [
+        {"task_id": "task-1", "project_id": "alpha", "completed": True, "story_points": 5, "updated_day": 8},
+        {"task_id": "task-2", "project_id": "alpha", "completed": False, "story_points": 3, "updated_day": 1},
+        {"task_id": "task-3", "project_id": "beta", "completed": False, "story_points": 8, "updated_day": 1},
+    ]

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/metrics.py

@@ -0,0 +1,29 @@
+from .models import ProjectMetrics
+
+
+STALE_DAY_THRESHOLD = 10
+
+
+def calculate_project_metrics(tasks, current_day):
+    grouped = {}
+    for task in tasks:
+        grouped.setdefault(task.project_id, []).append(task)
+
+    metrics = []
+    for project_id in sorted(grouped):
+        project_tasks = grouped[project_id]
+        completed = sum(1 for task in project_tasks if task.completed)
+        stale = sum(1 for task in project_tasks if not task.completed and current_day - task.updated_day >= STALE_DAY_THRESHOLD)
+        total = len(project_tasks)
+        metrics.append(
+            ProjectMetrics(
+                project_id=project_id,
+                total_tasks=total,
+                completed_tasks=completed,
+                open_tasks=total - completed,
+                stale_tasks=stale,
+                completion_rate=round((completed / total) * 100, 2) if total else 0.0,
+                average_story_points=round(sum(task.story_points for task in project_tasks) / total, 2) if total else 0.0,
+            )
+        )
+    return metrics

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/models.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class TaskRecord:
+    task_id: str
+    project_id: str
+    completed: bool
+    story_points: int
+    updated_day: int
+
+
+@dataclass(frozen=True)
+class ProjectMetrics:
+    project_id: str
+    total_tasks: int
+    completed_tasks: int
+    open_tasks: int
+    stale_tasks: int
+    completion_rate: float
+    average_story_points: float

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/parser.py

@@ -0,0 +1,16 @@
+from .models import TaskRecord
+
+
+def parse_task_rows(rows):
+    records = []
+    for row in rows:
+        records.append(
+            TaskRecord(
+                task_id=str(row["task_id"]),
+                project_id=str(row["project_id"]),
+                completed=bool(row["completed"]),
+                story_points=int(row["story_points"]),
+                updated_day=int(row["updated_day"]),
+            )
+        )
+    return records

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/pipeline.py

@@ -0,0 +1,9 @@
+from .metrics import calculate_project_metrics
+from .parser import parse_task_rows
+from .reporting import build_health_report
+
+
+def build_report_from_rows(rows, current_day):
+    tasks = parse_task_rows(rows)
+    metrics = calculate_project_metrics(tasks, current_day)
+    return build_health_report(metrics)

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/quality.py

@@ -0,0 +1,8 @@
+def determine_quality_label(metric):
+    if metric.total_tasks == 0:
+        return "empty"
+    if metric.completion_rate >= 80 and metric.stale_tasks == 0:
+        return "healthy"
+    if metric.completion_rate >= 50 and metric.stale_tasks <= 1:
+        return "watch"
+    return "risk"

package/benchmarks/projects/task-analytics-large-mixed/py/task_analytics/reporting.py

@@ -0,0 +1,11 @@
+from .quality import determine_quality_label
+
+
+def build_health_report(metrics):
+    lines = []
+    for metric in metrics:
+        label = determine_quality_label(metric)
+        lines.append(
+            f"{metric.project_id}: {label} | completion={metric.completion_rate}% | open={metric.open_tasks} | stale={metric.stale_tasks}"
+        )
+    return "\n".join(lines)

package/benchmarks/projects/task-analytics-large-mixed/py/tests/test_metrics.py

@@ -0,0 +1,19 @@
+import unittest
+
+from task_analytics.fixtures import sample_rows
+from task_analytics.metrics import calculate_project_metrics
+from task_analytics.parser import parse_task_rows
+
+
+class MetricsTests(unittest.TestCase):
+    def test_calculate_project_metrics(self):
+        metrics = calculate_project_metrics(parse_task_rows(sample_rows()), 15)
+        self.assertEqual(metrics[0].project_id, "alpha")
+        self.assertEqual(metrics[0].completion_rate, 50.0)
+        self.assertEqual(metrics[0].stale_tasks, 1)
+        self.assertEqual(metrics[1].project_id, "beta")
+        self.assertEqual(metrics[1].completion_rate, 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/benchmarks/projects/task-analytics-large-mixed/py/tests/test_parser.py

@@ -0,0 +1,15 @@
+import unittest
+
+from task_analytics.parser import parse_task_rows
+
+
+class ParserTests(unittest.TestCase):
+    def test_parse_task_rows(self):
+        rows = [{"task_id": "task-1", "project_id": "alpha", "completed": False, "story_points": 3, "updated_day": 2}]
+        parsed = parse_task_rows(rows)
+        self.assertEqual(parsed[0].task_id, "task-1")
+        self.assertFalse(parsed[0].completed)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/benchmarks/projects/task-analytics-large-mixed/py/tests/test_quality.py

@@ -0,0 +1,19 @@
+import unittest
+
+from task_analytics.metrics import calculate_project_metrics
+from task_analytics.parser import parse_task_rows
+from task_analytics.quality import determine_quality_label
+
+
+class QualityTests(unittest.TestCase):
+    def test_determine_quality_label(self):
+        rows = [
+            {"task_id": "task-1", "project_id": "alpha", "completed": True, "story_points": 5, "updated_day": 8},
+            {"task_id": "task-2", "project_id": "alpha", "completed": True, "story_points": 3, "updated_day": 7},
+        ]
+        metrics = calculate_project_metrics(parse_task_rows(rows), 15)
+        self.assertEqual(determine_quality_label(metrics[0]), "healthy")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/benchmarks/projects/task-analytics-large-mixed/py/tests/test_reporting.py

@@ -0,0 +1,15 @@
+import unittest
+
+from task_analytics.fixtures import sample_rows
+from task_analytics.pipeline import build_report_from_rows
+
+
+class ReportingTests(unittest.TestCase):
+    def test_build_report_from_rows(self):
+        report = build_report_from_rows(sample_rows(), 15)
+        self.assertIn("alpha: watch", report)
+        self.assertIn("beta: risk", report)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

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

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

@@ -0,0 +1,11 @@
+export * from "./models/analyticsSnapshot.js";
+export * from "./models/project.js";
+export * from "./models/task.js";
+export * from "./reporting/buildProjectLeaderboard.js";
+export * from "./reporting/formatTaskHealthReport.js";
+export * from "./services/buildAnalyticsSnapshot.js";
+export * from "./services/completeTask.js";
+export * from "./services/createTask.js";
+export * from "./services/listTasksByProject.js";
+export * from "./store/projectStore.js";
+export * from "./store/taskStore.js";

package/benchmarks/projects/task-analytics-large-mixed/ts/src/models/analyticsSnapshot.ts

@@ -0,0 +1,20 @@
+export type ProjectSnapshot = {
+  projectId: string;
+  totalTasks: number;
+  completedTasks: number;
+  openTasks: number;
+  staleTasks: number;
+  averageStoryPoints: number;
+  completionRate: number;
+};
+
+export type AnalyticsSnapshot = {
+  generatedAt: string;
+  projects: ProjectSnapshot[];
+  totals: {
+    totalTasks: number;
+    completedTasks: number;
+    openTasks: number;
+    staleTasks: number;
+  };
+};

package/benchmarks/projects/task-analytics-large-mixed/ts/src/models/project.ts

@@ -0,0 +1,5 @@
+export type AnalyticsProject = {
+  id: string;
+  name: string;
+  owner: string;
+};

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

@@ -0,0 +1,10 @@
+export type AnalyticsTask = {
+  id: string;
+  title: string;
+  projectId: string;
+  assignee: string;
+  completed: boolean;
+  storyPoints: number;
+  updatedDay: number;
+  labels: string[];
+};

package/benchmarks/projects/task-analytics-large-mixed/ts/src/reporting/buildProjectLeaderboard.ts

@@ -0,0 +1,7 @@
+import type { AnalyticsSnapshot } from "../models/analyticsSnapshot.js";
+
+export function buildProjectLeaderboard(snapshot: AnalyticsSnapshot): string[] {
+  return [...snapshot.projects]
+    .sort((left, right) => right.completionRate - left.completionRate || left.staleTasks - right.staleTasks || left.projectId.localeCompare(right.projectId))
+    .map((project, index) => `${index + 1}. ${project.projectId} (${project.completionRate}% complete, ${project.staleTasks} stale)`);
+}

package/benchmarks/projects/task-analytics-large-mixed/ts/src/reporting/formatTaskHealthReport.ts

@@ -0,0 +1,13 @@
+import type { AnalyticsSnapshot } from "../models/analyticsSnapshot.js";
+import { buildProjectLeaderboard } from "./buildProjectLeaderboard.js";
+
+export function formatTaskHealthReport(snapshot: AnalyticsSnapshot): string {
+  const leaderBoard = buildProjectLeaderboard(snapshot).join(" | ");
+  return [
+    `Total tasks: ${snapshot.totals.totalTasks}`,
+    `Completed: ${snapshot.totals.completedTasks}`,
+    `Open: ${snapshot.totals.openTasks}`,
+    `Stale: ${snapshot.totals.staleTasks}`,
+    `Projects: ${leaderBoard}`
+  ].join("\n");
+}

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

@@ -0,0 +1,39 @@
+import type { AnalyticsSnapshot, ProjectSnapshot } from "../models/analyticsSnapshot.js";
+import { ProjectStore } from "../store/projectStore.js";
+import { AnalyticsTaskStore } from "../store/taskStore.js";
+import { listTasksByProject } from "./listTasksByProject.js";
+
+const STALE_DAY_THRESHOLD = 10;
+
+export function buildAnalyticsSnapshot(taskStore: AnalyticsTaskStore, projectStore: ProjectStore, currentDay: number): AnalyticsSnapshot {
+  const projects = projectStore.list();
+  const snapshots: ProjectSnapshot[] = projects.map((project) => {
+    const tasks = listTasksByProject(taskStore, project.id);
+    const completedTasks = tasks.filter((task) => task.completed).length;
+    const staleTasks = tasks.filter((task) => !task.completed && currentDay - task.updatedDay >= STALE_DAY_THRESHOLD).length;
+    return {
+      projectId: project.id,
+      totalTasks: tasks.length,
+      completedTasks,
+      openTasks: tasks.length - completedTasks,
+      staleTasks,
+      averageStoryPoints: tasks.length === 0 ? 0 : round(tasks.reduce((sum, task) => sum + task.storyPoints, 0) / tasks.length),
+      completionRate: tasks.length === 0 ? 0 : round((completedTasks / tasks.length) * 100)
+    };
+  });
+
+  return {
+    generatedAt: `2026-03-${String(currentDay).padStart(2, "0")}T00:00:00.000Z`,
+    projects: snapshots,
+    totals: {
+      totalTasks: snapshots.reduce((sum, snapshot) => sum + snapshot.totalTasks, 0),
+      completedTasks: snapshots.reduce((sum, snapshot) => sum + snapshot.completedTasks, 0),
+      openTasks: snapshots.reduce((sum, snapshot) => sum + snapshot.openTasks, 0),
+      staleTasks: snapshots.reduce((sum, snapshot) => sum + snapshot.staleTasks, 0)
+    }
+  };
+}
+
+function round(value: number): number {
+  return Math.round(value * 100) / 100;
+}