@xn-intenton-z2a/agentic-lib 7.4.43 → 7.4.44

package/.github/agents/agent-report.md

@@ -1,100 +1,56 @@
 ---
-description: Generate enriched benchmark reports by analysing mechanically gathered pipeline data
+description: Investigate benchmark data via tools and produce structured findings with evidence
 ---
 
-You are a benchmark analyst for an autonomous coding pipeline. You have been given a comprehensive mechanical data dump covering a specific time period for a single repository. Your job is to enrich this data into a structured benchmark report with analysis, verified acceptance criteria, and recommendations.
+You are a benchmark analyst for an autonomous coding pipeline. Data has been gathered to files on disk. Your job is to **investigate** using tools, not just summarise — dig into source code, issues, PRs, and commits to produce findings like those in a professional benchmark report.
 
 ## Available Tools
 
-- `read_file` — Read any file in the repository. Use this to verify acceptance criteria by reading source code, check test implementations, read configuration, and examine mission files.
-- `list_files` — Browse the repository directory structure to discover additional source files, test files, and feature documents.
-- `list_issues` / `get_issue` — Query open and closed issues to understand what work was done, trace issues to features and code changes, and identify issue churn.
-- `list_prs` — Query pull requests (open, closed, merged) to trace code changes back to issues and understand the transformation pipeline.
-- `git_diff` / `git_status` — View the current state of the working tree.
-- `report_analysis` — **Required.** Call this exactly once to record your enriched analysis. Pass a JSON object with all required fields.
+- `read_file` — Read files on disk. Key data files are in `/tmp/report-data/`:
+  - `mission.md` — The MISSION.md with acceptance criteria
+  - `config.toml` — Full agentic-lib.toml configuration
+  - `state.toml` — Persistent state (counters, budget, mission status)
+  - `workflow-runs.json` — All workflow runs with timing and outcome
+  - `commits.json` — All commits with messages and authors
+  - `issues.json` — Issues with labels and state
+  - `pull-requests.json` — PRs with branches and merge info
+- `read_file` — Also read repository files directly: `src/lib/main.js`, `tests/unit/*.test.js`, `README.md`
+- `list_files` — Browse directory structure
+- `list_issues` / `get_issue` — Get full issue details including body and comments
+- `list_prs` — Query PRs
+- `git_diff` / `git_status` — View working tree state
+- `report_analysis` — **Required.** Call exactly once with your structured analysis.
 
-> **Use tools aggressively.** The mechanical data gives you the overview — your job is to dig deeper. Read source code to verify acceptance criteria. Read issues and PRs to understand the narrative of what happened. Read commits to trace changes. Don't just trust issue titles — read the bodies and the actual code.
+## How to Work
 
-## Context Provided (Mechanical Data)
+**Do NOT summarise or concatenate raw data.** Instead:
 
-The task handler has already gathered and included in the prompt:
+1. **Read the mission** (`/tmp/report-data/mission.md`) — extract each acceptance criterion
+2. **Read the source code** (`src/lib/main.js`) — verify each criterion is implemented
+3. **Read workflow-runs.json** — identify which runs produced transforms vs maintenance
+4. **Cross-reference with pull-requests.json** — map transforms to merged PRs
+5. **Read specific issues** (use `get_issue`) — understand what work was done
+6. **Look for problems** — failing runs, issue churn, budget exhaustion, stuck loops
 
-- **MISSION.md** — full mission text with extracted acceptance criteria
-- **agentic-lib.toml** — full configuration snapshot (model, profile, budget, paths, tuning)
-- **agentic-lib-state.toml** — full persistent state snapshot (counters, budget, status flags)
-- **Workflow runs** — all runs in the period with name, conclusion, timing, duration, and URLs
-- **Pull requests** — merged and open PRs with branch, title, additions/deletions, file count
-- **Commits** — all commits with SHA, message, author, timestamp
-- **Issues** — open and recently closed issues with labels, title, body excerpts
-- **Source code** — full contents of all source files (src/lib/*.js), not just line counts
-- **Test files** — full contents of all test files, not just filenames
-- **Agent log excerpts** — narrative excerpts from the most recent agent log files
-- **Website HTML** — text summary of the GitHub Pages website content
-- **Screenshot** — whether SCREENSHOT_INDEX.png was captured (available as artifact)
-- **README.md** — repository README content
-- **Mission status** — whether MISSION_COMPLETE.md or MISSION_FAILED.md exist, with contents
+## What Good Findings Look Like
 
-## Your Task
+From BENCHMARK_REPORT_016.md:
 
-### 1. Verify Acceptance Criteria (CRITICAL)
+> ### FINDING-2: Autonomous dependency addition without lockfile update breaks CI (CRITICAL)
+> PR #32 added `sharp` to `package.json` without regenerating the lockfile. The LLM knew the mission required a PNG dependency... But the transform mechanism can only edit files — it cannot run `npm install`. This is a **structural gap** in the autonomous pipeline.
 
-For each criterion extracted from MISSION.md:
-- Use `read_file` to check source code for evidence of implementation
-- Use `list_issues` / `get_issue` to find related issues that addressed it
-- Mark each criterion as **PASS**, **FAIL**, or **NOT TESTED** with specific evidence (file path, line number, function name, or issue number)
-- Don't trust issue titles — verify in the actual code
+Notice: specific PR number, root cause analysis, structural insight, severity level.
 
-### 2. Build Iteration Narrative
+Bad finding: "The pipeline ran 8 workflow runs and produced 4 transforms." — This is just restating numbers from the data.
 
-For each workflow run in the period:
-- Was it an init run, a supervisor run, or a manual dispatch?
-- Did it produce a transform? (Check: was a PR merged in the same time window?)
-- What did the supervisor/director decide? (Check agent logs)
-- Map runs to PRs to commits to understand the transformation chain
+## What to Produce
 
-Write this as the `iteration_narrative` field — a clear prose timeline of what happened.
+Call `report_analysis` with:
 
-### 3. Assess Code Quality
+- **summary**: 2-3 sentences. What was the mission? Did it complete? What's the headline?
+- **iteration_narrative**: Prose timeline. "At 02:10, the first workflow run produced PR #9 which implemented the expression parser. At 03:36, a second transform added CSV loading via PR #11..." — map runs to PRs to actual changes.
+- **acceptance_criteria**: For EACH criterion from MISSION.md, read the source code and mark PASS/FAIL/NOT TESTED with evidence like "fizzBuzz() at src/lib/main.js:12 returns correct array — tested in tests/unit/fizzbuzz.test.js"
+- **findings**: Observations with severity. POSITIVE (what worked well), CONCERN (needs attention), CRITICAL (broken), REGRESSION (got worse), OBSERVATION (neutral insight). Every finding must cite specific evidence.
+- **recommendations**: Actionable next steps
 
-Read the source code included in the mechanical data:
-- Is the implementation correct and complete?
-- Are the tests meaningful (testing real behaviour) or trivial (testing existence)?
-- Are there TODO comments or incomplete implementations?
-- Does the code structure match what the mission asked for?
-
-### 4. Identify Findings
-
-Each finding should be categorised as:
-- **POSITIVE** — something that worked well
-- **CONCERN** — something that needs attention
-- **REGRESSION** — something that got worse compared to expected behaviour
-
-Every finding must cite evidence (file path, issue number, commit SHA, or workflow run ID).
-
-### 5. Produce Scenario Summary
-
-Fill in the `scenario_summary` object:
-- `total_iterations`: total workflow runs
-- `transforms`: how many produced merged PRs with code changes
-- `convergence_iteration`: which iteration reached mission-complete (0 if not)
-- `final_source_lines`: line count of main source file
-- `final_test_count`: number of test files
-- `acceptance_pass_count`: e.g. "7/8 PASS"
-- `total_tokens`: from state file counters
-
-### 6. Make Recommendations
-
-Actionable next steps for improving the pipeline, the mission, or the code. Be specific.
-
-### 7. Call `report_analysis`
-
-Record your complete analysis as a structured JSON object. This is mandatory — the report cannot be enriched without it.
-
-## Report Quality Standards
-
-- Every claim must cite evidence
-- Acceptance criteria assessment must read the actual source code
-- Compare state file counters with observed workflow runs for consistency
-- Note any discrepancies between what the pipeline reports and what actually happened
-- Be honest about failures — a clear failure report is more valuable than a vague success report
-- Include the iteration narrative as prose, not just a table
+**You MUST call report_analysis exactly once.**

package/.github/workflows/agentic-lib-workflow.yml

@@ -48,6 +48,10 @@ on:
         type: string
         required: false
         default: ""
+      message:
+        type: string
+        required: false
+        default: ""
   workflow_dispatch:
     inputs:
       model:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xn-intenton-z2a/agentic-lib",
-  "version": "7.4.43",
+  "version": "7.4.44",
   "description": "Agentic-lib Agentic Coding Systems SDK powering automated GitHub workflows.",
   "type": "module",
   "scripts": {

package/src/actions/agentic-step/tasks/report.js

@@ -1,18 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-only
 // Copyright (C) 2025-2026 Polycode Limited
-// tasks/report.js — Benchmark report: mechanical data gathering + optional LLM enrichment
+// tasks/report.js — Benchmark report: gather data to filesystem, LLM analyses via tools
 //
-// Gathers configuration, state, workflow runs, commits, issues, PRs, source code,
-// test files, agent logs, screenshots, and website HTML for a given time period.
-// Produces a structured markdown report comparable to what a Claude Code session
-// would write following ITERATION_BENCHMARKS_SIMPLE.md.
+// Pattern: write mechanical data to files on disk, give the LLM a concise summary
+// pointing it at those files + tools, LLM investigates and calls report_analysis
+// with structured findings. The handler writes the final report markdown.
 
 import * as core from "@actions/core";
-import { existsSync, readFileSync, readdirSync } from "fs";
-import { readOptionalFile, scanDirectory, NARRATIVE_INSTRUCTION } from "../copilot.js";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { readOptionalFile, NARRATIVE_INSTRUCTION } from "../copilot.js";
 import { runCopilotSession } from "../../../copilot/copilot-session.js";
 import { createGitHubTools, createGitTools } from "../../../copilot/github-tools.js";
 
+const REPORT_DATA_DIR = "/tmp/report-data";
+
 /**
  * Discover the most recent init workflow run timestamp via GitHub API.
  */
@@ -32,440 +33,299 @@ async function findLatestInitRun(octokit, owner, repo) {
 }
 
 /**
- * List workflow runs in the period.
+ * Gather all mechanical data and write it to files in REPORT_DATA_DIR.
+ * Returns a summary object with counts and key facts.
  */
-async function listWorkflowRuns(octokit, owner, repo, since, until) {
-  const runs = [];
+async function gatherAndWriteData(octokit, owner, repoName, periodStart, periodEnd, config) {
+  mkdirSync(REPORT_DATA_DIR, { recursive: true });
+
+  // 1. Config and state (already on disk, just copy references)
+  const configContent = readOptionalFile(config._configPath || "agentic-lib.toml") || "";
+  const stateContent = readOptionalFile("agentic-lib-state.toml") || "";
+  const missionContent = readOptionalFile("MISSION.md") || "";
+  writeFileSync(`${REPORT_DATA_DIR}/config.toml`, configContent);
+  writeFileSync(`${REPORT_DATA_DIR}/state.toml`, stateContent);
+  writeFileSync(`${REPORT_DATA_DIR}/mission.md`, missionContent);
+
+  // 2. Workflow runs
+  let workflowRuns = [];
   try {
     const { data } = await octokit.rest.actions.listWorkflowRunsForRepo({
-      owner, repo, per_page: 50, created: `${since}..${until}`,
+      owner, repo: repoName, per_page: 50, created: `${periodStart}..${periodEnd}`,
     });
-    for (const r of data.workflow_runs) {
-      runs.push({
-        id: r.id, name: r.name, status: r.status, conclusion: r.conclusion,
-        created_at: r.created_at, updated_at: r.updated_at,
-        html_url: r.html_url,
-      });
-    }
-  } catch (err) {
-    core.warning(`Could not list workflow runs: ${err.message}`);
-  }
-  return runs;
-}
-
-/**
- * List commits in the period.
- */
-async function listCommits(octokit, owner, repo, since, until) {
-  const commits = [];
+    workflowRuns = data.workflow_runs.map(r => ({
+      id: r.id, name: r.name, status: r.status, conclusion: r.conclusion,
+      created_at: r.created_at, updated_at: r.updated_at, html_url: r.html_url,
+    }));
+  } catch (err) { core.warning(`Could not list runs: ${err.message}`); }
+  writeFileSync(`${REPORT_DATA_DIR}/workflow-runs.json`, JSON.stringify(workflowRuns, null, 2));
+
+  // 3. Commits
+  let commits = [];
   try {
     const { data } = await octokit.rest.repos.listCommits({
-      owner, repo, since, until, per_page: 100,
+      owner, repo: repoName, since: periodStart, until: periodEnd, per_page: 100,
     });
-    for (const c of data) {
-      commits.push({
-        sha: c.sha.substring(0, 8),
-        message: c.commit.message.split("\n")[0],
-        author: c.commit.author?.name || "unknown",
-        date: c.commit.author?.date || "",
-      });
-    }
-  } catch (err) {
-    core.warning(`Could not list commits: ${err.message}`);
-  }
-  return commits;
-}
-
-/**
- * List issues (open + recently closed) with bodies for context.
- */
-async function listIssues(octokit, owner, repo, since) {
-  const issues = [];
+    commits = data.map(c => ({
+      sha: c.sha.substring(0, 8), message: c.commit.message.split("\n")[0],
+      author: c.commit.author?.name || "unknown", date: c.commit.author?.date || "",
+    }));
+  } catch (err) { core.warning(`Could not list commits: ${err.message}`); }
+  writeFileSync(`${REPORT_DATA_DIR}/commits.json`, JSON.stringify(commits, null, 2));
+
+  // 4. Issues (open + recently closed)
+  let issues = [];
   for (const state of ["open", "closed"]) {
     try {
       const { data } = await octokit.rest.issues.listForRepo({
-        owner, repo, state, since, per_page: 50, sort: "created", direction: "desc",
+        owner, repo: repoName, state, since: periodStart, per_page: 50,
+        sort: "created", direction: "desc",
       });
       for (const i of data) {
         if (i.pull_request) continue;
         issues.push({
           number: i.number, state: i.state, title: i.title,
-          labels: i.labels.map(l => l.name).join(", "),
-          created_at: i.created_at, closed_at: i.closed_at,
-          body: i.body ? i.body.substring(0, 500) : "",
+          labels: i.labels.map(l => l.name), created_at: i.created_at,
+          closed_at: i.closed_at,
         });
       }
     } catch { /* ignore */ }
   }
-  return issues;
-}
+  writeFileSync(`${REPORT_DATA_DIR}/issues.json`, JSON.stringify(issues, null, 2));
 
-/**
- * List PRs (merged + open) with diff stats.
- */
-async function listPullRequests(octokit, owner, repo, since) {
-  const prs = [];
+  // 5. PRs (merged + open)
+  let prs = [];
   for (const state of ["closed", "open"]) {
     try {
       const { data } = await octokit.rest.pulls.list({
-        owner, repo, state, per_page: 30, sort: "created", direction: "desc",
+        owner, repo: repoName, state, per_page: 30, sort: "created", direction: "desc",
       });
       for (const p of data) {
         if (state === "closed" && !p.merged_at) continue;
-        if (new Date(p.created_at) < new Date(since)) continue;
+        if (new Date(p.created_at) < new Date(periodStart)) continue;
         prs.push({
           number: p.number, title: p.title, state: p.state,
           branch: p.head?.ref || "", merged_at: p.merged_at,
-          created_at: p.created_at,
           additions: p.additions || 0, deletions: p.deletions || 0,
-          changed_files: p.changed_files || 0,
         });
       }
     } catch { /* ignore */ }
   }
-  return prs;
-}
-
-/**
- * Read source file contents (with size limit per file).
- */
-function readSourceFiles(config) {
-  const files = [];
-  const MAX_CHARS = 5000;
-  const srcPath = config.paths?.source?.path || "src/lib/main.js";
-  const srcDir = "src/lib";
-
-  // Collect all source files
-  const filePaths = [];
-  if (existsSync(srcPath)) filePaths.push(srcPath);
-  if (existsSync(srcDir)) {
-    try {
-      for (const f of readdirSync(srcDir)) {
-        const fp = `${srcDir}/${f}`;
-        if (fp === srcPath) continue;
-        if (f.endsWith(".js") || f.endsWith(".ts")) filePaths.push(fp);
-      }
-    } catch { /* ignore */ }
-  }
+  writeFileSync(`${REPORT_DATA_DIR}/pull-requests.json`, JSON.stringify(prs, null, 2));
+
+  // 6. Mission status
+  const missionComplete = existsSync("MISSION_COMPLETE.md");
+  const missionFailed = existsSync("MISSION_FAILED.md");
+  const completeContent = missionComplete ? readFileSync("MISSION_COMPLETE.md", "utf8") : "";
+  const failedContent = missionFailed ? readFileSync("MISSION_FAILED.md", "utf8") : "";
+
+  // Parse key state values
+  let budgetUsed = 0, budgetCap = 0, totalTokens = 0, transforms = 0;
+  const budgetUsedMatch = stateContent.match(/transformation-budget-used\s*=\s*(\d+)/);
+  const budgetCapMatch = stateContent.match(/transformation-budget-cap\s*=\s*(\d+)/);
+  const tokensMatch = stateContent.match(/total-tokens\s*=\s*(\d+)/);
+  const transformsMatch = stateContent.match(/cumulative-transforms\s*=\s*(\d+)/);
+  if (budgetUsedMatch) budgetUsed = parseInt(budgetUsedMatch[1]);
+  if (budgetCapMatch) budgetCap = parseInt(budgetCapMatch[1]);
+  if (tokensMatch) totalTokens = parseInt(tokensMatch[1]);
+  if (transformsMatch) transforms = parseInt(transformsMatch[1]);
 
-  for (const fp of filePaths) {
-    try {
-      const content = readFileSync(fp, "utf8");
-      files.push({
-        file: fp,
-        lines: content.split("\n").length,
-        content: content.length > MAX_CHARS
-          ? content.substring(0, MAX_CHARS) + `\n... (truncated at ${MAX_CHARS} chars, total ${content.length})`
-          : content,
-      });
-    } catch { /* ignore */ }
-  }
-  return files;
-}
-
-/**
- * Read test file contents (with size limit).
- */
-function readTestFiles() {
-  const files = [];
-  const MAX_CHARS = 3000;
-  for (const dir of ["tests", "tests/unit", "__tests__"]) {
-    if (!existsSync(dir)) continue;
-    try {
-      for (const f of readdirSync(dir)) {
-        if (!f.endsWith(".test.js") && !f.endsWith(".test.ts") && !f.endsWith(".spec.js")) continue;
-        const fp = `${dir}/${f}`;
-        try {
-          const content = readFileSync(fp, "utf8");
-          files.push({
-            file: fp,
-            lines: content.split("\n").length,
-            content: content.length > MAX_CHARS
-              ? content.substring(0, MAX_CHARS) + `\n... (truncated)`
-              : content,
-          });
-        } catch { /* ignore */ }
-      }
-    } catch { /* ignore */ }
-  }
-  return files;
-}
-
-/**
- * Read agent log file contents (last N logs).
- */
-function readAgentLogs(logPrefix, maxLogs = 10) {
-  const logDir = logPrefix.includes("/") ? logPrefix.substring(0, logPrefix.lastIndexOf("/")) : ".";
-  const logBase = logPrefix.includes("/") ? logPrefix.substring(logPrefix.lastIndexOf("/") + 1) : logPrefix;
-  const logs = [];
-  try {
-    const allLogs = readdirSync(logDir)
-      .filter(f => f.startsWith(logBase) && f.endsWith(".md"))
-      .sort();
-    // Take the most recent N logs
-    const recent = allLogs.slice(-maxLogs);
-    for (const f of recent) {
-      const fp = logDir === "." ? f : `${logDir}/${f}`;
-      try {
-        const content = readFileSync(fp, "utf8");
-        // Extract key info: first 80 lines
-        const lines = content.split("\n");
-        logs.push({
-          file: f,
-          excerpt: lines.slice(0, 80).join("\n"),
-          totalLines: lines.length,
-        });
-      } catch { /* ignore */ }
-    }
-  } catch { /* ignore */ }
-  return logs;
-}
-
-/**
- * Extract acceptance criteria from MISSION.md.
- * Looks for bullet points, numbered lists, or "Acceptance Criteria" sections.
- */
-function extractAcceptanceCriteria(missionContent) {
-  if (!missionContent) return [];
-  const criteria = [];
-  const lines = missionContent.split("\n");
-  let inCriteria = false;
-  for (const line of lines) {
-    const lower = line.toLowerCase();
-    if (lower.includes("acceptance") || lower.includes("criteria") || lower.includes("requirements")) {
-      inCriteria = true;
-      continue;
-    }
-    if (inCriteria && /^#+\s/.test(line) && !lower.includes("criteria")) {
-      inCriteria = false;
-    }
-    if (inCriteria) {
-      const match = line.match(/^[\s]*[-*]\s+(.+)/) || line.match(/^[\s]*\d+\.\s+(.+)/);
-      if (match) criteria.push(match[1].trim());
-    }
-  }
-  // If no explicit criteria section found, extract all bullet points as potential criteria
-  if (criteria.length === 0) {
-    for (const line of lines) {
-      const match = line.match(/^[\s]*[-*]\s+(.+)/);
-      if (match && match[1].length > 10) criteria.push(match[1].trim());
-    }
-  }
-  return criteria;
+  return {
+    periodStart, periodEnd,
+    workflowRunCount: workflowRuns.length,
+    commitCount: commits.length,
+    issueCount: issues.length,
+    openIssueCount: issues.filter(i => i.state === "open").length,
+    closedIssueCount: issues.filter(i => i.state === "closed").length,
+    prCount: prs.length,
+    mergedPrCount: prs.filter(p => p.merged_at).length,
+    missionComplete, missionFailed,
+    completeContent, failedContent,
+    budgetUsed, budgetCap, totalTokens, transforms,
+    missionContent,
+  };
 }
 
 /**
- * Read website HTML if available (placed by workflow).
+ * Build the concise prompt for the LLM (like supervisor's buildPrompt).
  */
-function readWebsiteHtml() {
-  const path = "/tmp/website.html";
-  if (existsSync(path)) {
-    const content = readFileSync(path, "utf8");
-    // Extract meaningful text content (strip tags, keep first 2000 chars)
-    const textContent = content
-      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
-      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
-      .replace(/<[^>]+>/g, " ")
-      .replace(/\s+/g, " ")
-      .trim();
-    return {
-      rawLength: content.length,
-      textSummary: textContent.substring(0, 2000),
-      hasContent: textContent.length > 100,
-    };
-  }
-  return null;
+function buildPrompt(summary, agentInstructions, repo) {
+  return [
+    "## Instructions",
+    agentInstructions,
+    "",
+    "## Report Period",
+    `Repository: ${repo.owner}/${repo.repo}`,
+    `Period: ${summary.periodStart} → ${summary.periodEnd}`,
+    "",
+    "## Summary of Gathered Data",
+    `Workflow runs: ${summary.workflowRunCount}`,
+    `Commits: ${summary.commitCount}`,
+    `Issues: ${summary.issueCount} (${summary.openIssueCount} open, ${summary.closedIssueCount} closed)`,
+    `Pull requests: ${summary.prCount} (${summary.mergedPrCount} merged)`,
+    `Cumulative transforms: ${summary.transforms}`,
+    `Budget: ${summary.budgetUsed}/${summary.budgetCap} used`,
+    `Total tokens consumed: ${summary.totalTokens}`,
+    `Mission complete: ${summary.missionComplete ? "YES" : "NO"}`,
+    `Mission failed: ${summary.missionFailed ? "YES" : "NO"}`,
+    "",
+    "## Data Files Available",
+    "The following files contain the full mechanical data. Use `read_file` to examine them:",
+    `- ${REPORT_DATA_DIR}/mission.md — MISSION.md with acceptance criteria`,
+    `- ${REPORT_DATA_DIR}/config.toml — Full agentic-lib.toml configuration`,
+    `- ${REPORT_DATA_DIR}/state.toml — Full agentic-lib-state.toml persistent state`,
+    `- ${REPORT_DATA_DIR}/workflow-runs.json — All ${summary.workflowRunCount} workflow runs with timing and URLs`,
+    `- ${REPORT_DATA_DIR}/commits.json — All ${summary.commitCount} commits with messages`,
+    `- ${REPORT_DATA_DIR}/issues.json — All ${summary.issueCount} issues with labels and state`,
+    `- ${REPORT_DATA_DIR}/pull-requests.json — All ${summary.prCount} PRs with branches and merge info`,
+    "",
+    "## Source Code and Tests",
+    "Use `read_file` and `list_files` to examine the actual source code and tests:",
+    "- `src/lib/main.js` — Main source file",
+    "- `tests/unit/` — Unit test directory",
+    "- `README.md` — Repository documentation",
+    "",
+    "## Your Task",
+    "1. Read the mission file to extract acceptance criteria",
+    "2. Read workflow-runs.json and pull-requests.json to build an iteration timeline",
+    "3. Read source code to verify each acceptance criterion (PASS/FAIL/NOT TESTED)",
+    "4. Read issues to understand what work was done and identify any churn",
+    "5. Investigate any failures or anomalies you find — use get_issue for details",
+    "6. Call `report_analysis` exactly once with your structured findings",
+    "",
+    "**You MUST call report_analysis exactly once.**",
+  ].join("\n");
 }
 
 /**
- * Build the mechanical report content.
+ * Build the final report markdown from the LLM analysis.
  */
-function buildMechanicalReport({
-  periodStart, periodEnd, config, stateContent, configContent,
-  workflowRuns, commits, issues, prs, sourceFiles, testFiles, agentLogs,
-  missionContent, acceptanceCriteria, websiteInfo, hasScreenshot, repo,
-}) {
-  const sections = [];
+function buildReportMarkdown(summary, analysis, repo, model) {
   const now = new Date().toISOString().split("T")[0];
+  const sections = [];
 
   sections.push(`# Benchmark Report`);
   sections.push(``);
   sections.push(`**Date**: ${now}`);
   sections.push(`**Repository**: ${repo.owner}/${repo.repo}`);
-  sections.push(`**Period**: ${periodStart} → ${periodEnd}`);
-  sections.push(`**Generated by**: agentic-lib-report (mechanical + LLM enrichment)`);
+  sections.push(`**Period**: ${summary.periodStart} → ${summary.periodEnd}`);
+  sections.push(`**Model**: ${model}`);
   sections.push(``);
   sections.push(`---`);
 
-  // ── Mission ──
-  sections.push(``);
-  sections.push(`## Mission`);
-  sections.push(``);
-  sections.push("```");
-  sections.push(missionContent || "(no MISSION.md found)");
-  sections.push("```");
-
-  if (acceptanceCriteria.length > 0) {
-    sections.push(``);
-    sections.push(`### Extracted Acceptance Criteria`);
-    sections.push(``);
-    for (let i = 0; i < acceptanceCriteria.length; i++) {
-      sections.push(`${i + 1}. ${acceptanceCriteria[i]}`);
-    }
-  }
-
-  // ── Configuration snapshot ──
+  // Summary
   sections.push(``);
-  sections.push(`## Configuration (agentic-lib.toml)`);
+  sections.push(`## Summary`);
   sections.push(``);
-  sections.push("```toml");
-  sections.push(configContent || "(not found)");
-  sections.push("```");
+  sections.push(analysis.summary || "(no summary provided)");
 
-  // ── State snapshot ──
+  // Configuration
   sections.push(``);
-  sections.push(`## State (agentic-lib-state.toml)`);
-  sections.push(``);
-  sections.push("```toml");
-  sections.push(stateContent || "(not found)");
-  sections.push("```");
-
-  // ── Mission status ──
+  sections.push(`---`);
   sections.push(``);
-  sections.push(`## Mission Status`);
+  sections.push(`## Configuration`);
   sections.push(``);
-  const complete = existsSync("MISSION_COMPLETE.md");
-  const failed = existsSync("MISSION_FAILED.md");
-  sections.push(`| Signal | Present |`);
-  sections.push(`|--------|---------|`);
-  sections.push(`| MISSION_COMPLETE.md | ${complete ? "YES" : "NO"} |`);
-  sections.push(`| MISSION_FAILED.md | ${failed ? "YES" : "NO"} |`);
-
-  if (complete) {
-    sections.push(``);
-    sections.push("```");
-    sections.push(readFileSync("MISSION_COMPLETE.md", "utf8").trim());
-    sections.push("```");
-  }
-  if (failed) {
+  sections.push(`| Parameter | Value |`);
+  sections.push(`|-----------|-------|`);
+  sections.push(`| Mission complete | ${summary.missionComplete ? "YES" : "NO"} |`);
+  sections.push(`| Mission failed | ${summary.missionFailed ? "YES" : "NO"} |`);
+  sections.push(`| Transforms | ${summary.transforms} |`);
+  sections.push(`| Budget | ${summary.budgetUsed}/${summary.budgetCap} |`);
+  sections.push(`| Total tokens | ${summary.totalTokens} |`);
+  sections.push(`| Workflow runs | ${summary.workflowRunCount} |`);
+  sections.push(`| Commits | ${summary.commitCount} |`);
+  sections.push(`| PRs merged | ${summary.mergedPrCount} |`);
+  sections.push(`| Issues (open/closed) | ${summary.openIssueCount}/${summary.closedIssueCount} |`);
+
+  // Iteration narrative
+  if (analysis.iteration_narrative) {
     sections.push(``);
-    sections.push("```");
-    sections.push(readFileSync("MISSION_FAILED.md", "utf8").trim());
-    sections.push("```");
-  }
-
-  // ── Workflow runs (iteration timeline) ──
-  sections.push(``);
-  sections.push(`## Workflow Runs (${workflowRuns.length})`);
-  sections.push(``);
-  sections.push(`| # | Name | Conclusion | Started | Duration | URL |`);
-  sections.push(`|---|------|------------|---------|----------|-----|`);
-  for (let i = 0; i < workflowRuns.length; i++) {
-    const r = workflowRuns[i];
-    const startMs = new Date(r.created_at).getTime();
-    const endMs = new Date(r.updated_at).getTime();
-    const durationMin = Math.round((endMs - startMs) / 60000);
-    sections.push(`| ${i + 1} | ${r.name} | ${r.conclusion || r.status} | ${r.created_at} | ~${durationMin}min | [${r.id}](${r.html_url}) |`);
-  }
-
-  // ── Pull Requests (transformation evidence) ──
-  sections.push(``);
-  sections.push(`## Pull Requests (${prs.length})`);
-  sections.push(``);
-  sections.push(`| # | Branch | Title | Merged | +/- | Files |`);
-  sections.push(`|---|--------|-------|--------|-----|-------|`);
-  for (const p of prs) {
-    sections.push(`| #${p.number} | ${p.branch} | ${p.title} | ${p.merged_at || "open"} | +${p.additions}/-${p.deletions} | ${p.changed_files} |`);
-  }
-
-  // ── Commits timeline ──
-  sections.push(``);
-  sections.push(`## Commits Timeline (${commits.length})`);
-  sections.push(``);
-  sections.push(`| SHA | Date | Author | Message |`);
-  sections.push(`|-----|------|--------|---------|`);
-  for (const c of commits) {
-    sections.push(`| ${c.sha} | ${c.date} | ${c.author} | ${c.message} |`);
-  }
-
-  // ── Issues ──
-  sections.push(``);
-  sections.push(`## Issues (${issues.length})`);
-  sections.push(``);
-  sections.push(`| # | State | Labels | Title |`);
-  sections.push(`|---|-------|--------|-------|`);
-  for (const i of issues) {
-    sections.push(`| #${i.number} | ${i.state} | ${i.labels || "-"} | ${i.title} |`);
-  }
-
-  // ── Source Code (full contents) ──
-  sections.push(``);
-  sections.push(`## Source Code (${sourceFiles.length} files)`);
-  for (const s of sourceFiles) {
+    sections.push(`---`);
     sections.push(``);
-    sections.push(`### ${s.file} (${s.lines} lines)`);
+    sections.push(`## Timeline`);
     sections.push(``);
-    sections.push("```javascript");
-    sections.push(s.content);
-    sections.push("```");
+    sections.push(analysis.iteration_narrative);
   }
 
-  // ── Test Files (full contents) ──
-  sections.push(``);
-  sections.push(`## Test Files (${testFiles.length} files)`);
-  for (const t of testFiles) {
+  // Acceptance criteria
+  if (analysis.acceptance_criteria?.length) {
     sections.push(``);
-    sections.push(`### ${t.file} (${t.lines} lines)`);
+    sections.push(`---`);
     sections.push(``);
-    sections.push("```javascript");
-    sections.push(t.content);
-    sections.push("```");
-  }
-
-  // ── Website & Screenshot ──
-  sections.push(``);
-  sections.push(`## Website & Screenshot`);
-  sections.push(``);
-  sections.push(`**Screenshot**: ${hasScreenshot ? "SCREENSHOT_INDEX.png captured (see artifacts)" : "not available"}`);
-  sections.push(``);
-  if (websiteInfo) {
-    sections.push(`**Website** (${websiteInfo.rawLength} bytes, ${websiteInfo.hasContent ? "has content" : "minimal content"}):`);
+    sections.push(`## Acceptance Criteria`);
     sections.push(``);
-    sections.push("```");
-    sections.push(websiteInfo.textSummary);
-    sections.push("```");
-  } else {
-    sections.push(`**Website**: not fetched`);
+    sections.push(`| Criterion | Status | Evidence |`);
+    sections.push(`|-----------|--------|----------|`);
+    for (const ac of analysis.acceptance_criteria) {
+      sections.push(`| ${ac.criterion} | ${ac.status} | ${ac.evidence} |`);
+    }
   }
 
-  // ── Agent Log Narratives ──
-  sections.push(``);
-  sections.push(`## Agent Logs (${agentLogs.length} files)`);
-  for (const log of agentLogs) {
+  // Findings
+  if (analysis.findings?.length) {
     sections.push(``);
-    sections.push(`### ${log.file} (${log.totalLines} lines)`);
+    sections.push(`---`);
     sections.push(``);
-    sections.push("```");
-    sections.push(log.excerpt);
-    if (log.totalLines > 80) sections.push(`... (${log.totalLines - 80} more lines)`);
-    sections.push("```");
+    sections.push(`## Findings`);
+    for (const f of analysis.findings) {
+      sections.push(``);
+      sections.push(`### ${f.id}: ${f.title} (${f.severity})`);
+      sections.push(``);
+      sections.push(f.description);
+    }
   }
 
-  // ── README ──
-  const readmeContent = readOptionalFile("README.md");
-  if (readmeContent) {
+  // Recommendations
+  if (analysis.recommendations?.length) {
     sections.push(``);
-    sections.push(`## README.md`);
+    sections.push(`---`);
     sections.push(``);
-    const readmeLines = readmeContent.split("\n");
-    sections.push(readmeLines.slice(0, 60).join("\n"));
-    if (readmeLines.length > 60) sections.push(`\n... (${readmeLines.length - 60} more lines)`);
+    sections.push(`## Recommendations`);
+    sections.push(``);
+    for (let i = 0; i < analysis.recommendations.length; i++) {
+      sections.push(`${i + 1}. ${analysis.recommendations[i]}`);
+    }
   }
 
   sections.push(``);
   return sections.join("\n");
 }
 
+/**
+ * Build a mechanical-only fallback report (no LLM).
+ */
+function buildFallbackReport(summary, repo) {
+  const now = new Date().toISOString().split("T")[0];
+  return [
+    `# Benchmark Report`,
+    ``,
+    `**Date**: ${now}`,
+    `**Repository**: ${repo.owner}/${repo.repo}`,
+    `**Period**: ${summary.periodStart} → ${summary.periodEnd}`,
+    `**Generated by**: agentic-lib-report (mechanical — no LLM enrichment)`,
+    ``,
+    `---`,
+    ``,
+    `## Summary`,
+    ``,
+    `| Metric | Value |`,
+    `|--------|-------|`,
+    `| Mission complete | ${summary.missionComplete ? "YES" : "NO"} |`,
+    `| Mission failed | ${summary.missionFailed ? "YES" : "NO"} |`,
+    `| Transforms | ${summary.transforms} |`,
+    `| Budget | ${summary.budgetUsed}/${summary.budgetCap} |`,
+    `| Total tokens | ${summary.totalTokens} |`,
+    `| Workflow runs | ${summary.workflowRunCount} |`,
+    `| Commits | ${summary.commitCount} |`,
+    `| PRs merged | ${summary.mergedPrCount} |`,
+    `| Issues (open/closed) | ${summary.openIssueCount}/${summary.closedIssueCount} |`,
+    ``,
+    `> This report contains only mechanical data. LLM enrichment was not available.`,
+    `> For a full report with findings and acceptance criteria verification, ensure COPILOT_GITHUB_TOKEN is set.`,
+    ``,
+  ].join("\n");
+}
+
 /**
  * Report task handler.
  */
@@ -483,202 +343,109 @@ export async function report(context) {
   }
   core.info(`Report period: ${periodStart} → ${periodEnd}`);
 
-  // Read config and state files
-  const configPath = config._configPath || "agentic-lib.toml";
-  const configContent = readOptionalFile(configPath);
-  const stateContent = readOptionalFile("agentic-lib-state.toml");
-  const missionContent = readOptionalFile("MISSION.md");
-  const acceptanceCriteria = extractAcceptanceCriteria(missionContent || "");
-
-  // Gather data from GitHub API
-  const workflowRuns = await listWorkflowRuns(octokit, owner, repoName, periodStart, periodEnd);
-  const commits = await listCommits(octokit, owner, repoName, periodStart, periodEnd);
-  const issues = await listIssues(octokit, owner, repoName, periodStart);
-  const prs = await listPullRequests(octokit, owner, repoName, periodStart);
-
-  // Gather local data: full file contents, not just stats
-  const sourceFiles = readSourceFiles(config);
-  const testFiles = readTestFiles();
-  const logPrefix = config.intentionBot?.logPrefix || "agent-log-";
-  const agentLogs = readAgentLogs(logPrefix);
-  const websiteInfo = readWebsiteHtml();
-  const hasScreenshot = existsSync("SCREENSHOT_INDEX.png");
-
-  core.info(`Gathered: ${workflowRuns.length} runs, ${commits.length} commits, ${issues.length} issues, ${prs.length} PRs, ${sourceFiles.length} source files, ${testFiles.length} test files, ${agentLogs.length} logs`);
-
-  // Build mechanical report
-  const mechanicalReport = buildMechanicalReport({
-    periodStart, periodEnd, config, stateContent, configContent,
-    workflowRuns, commits, issues, prs, sourceFiles, testFiles, agentLogs,
-    missionContent, acceptanceCriteria, websiteInfo, hasScreenshot, repo,
-  });
-
-  // Optional LLM enrichment (if Copilot token available)
-  let enrichedAnalysis = null;
+  // Gather all data and write to filesystem
+  const summary = await gatherAndWriteData(octokit, owner, repoName, periodStart, periodEnd, config);
+  core.info(`Gathered: ${summary.workflowRunCount} runs, ${summary.commitCount} commits, ${summary.issueCount} issues, ${summary.prCount} PRs`);
+
+  // LLM enrichment (required for a proper report)
+  let analysis = null;
   let tokensUsed = 0;
   let resultModel = model;
+
   if (process.env.COPILOT_GITHUB_TOKEN) {
-    try {
-      const agentPrompt = context.instructions || "";
-      const tools = [
-        ...createGitHubTools(octokit, owner, repoName),
-        ...createGitTools(),
-        {
-          name: "report_analysis",
-          description: "Record your enriched analysis of the benchmark data. Call exactly once.",
-          parameters: {
-            type: "object",
-            properties: {
-              summary: { type: "string", description: "Executive summary of the benchmark period" },
-              findings: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    id: { type: "string" },
-                    title: { type: "string" },
-                    severity: { type: "string", enum: ["POSITIVE", "CONCERN", "REGRESSION"] },
-                    description: { type: "string" },
-                  },
-                  required: ["id", "title", "severity", "description"],
-                },
-              },
-              recommendations: { type: "array", items: { type: "string" } },
-              acceptance_criteria: {
-                type: "array",
-                items: {
-                  type: "object",
-                  properties: {
-                    criterion: { type: "string" },
-                    status: { type: "string", enum: ["PASS", "FAIL", "NOT TESTED"] },
-                    evidence: { type: "string" },
-                  },
-                  required: ["criterion", "status", "evidence"],
+    const agentInstructions = context.instructions || "You are a benchmark analyst. Investigate the data and produce findings.";
+
+    const createTools = (defineTool, _wp, logger) => {
+      const ghTools = createGitHubTools(octokit, owner, repoName, defineTool, logger);
+      const gitTools = createGitTools(defineTool, logger);
+
+      const reportTool = defineTool("report_analysis", {
+        description: "Record your benchmark analysis. Call exactly once with structured findings, acceptance criteria verification, timeline narrative, and recommendations.",
+        parameters: {
+          type: "object",
+          properties: {
+            summary: { type: "string", description: "Executive summary — what happened in this benchmark period, key outcomes" },
+            iteration_narrative: { type: "string", description: "Prose timeline: for each significant event, what happened, what changed, which PRs were created/merged" },
+            acceptance_criteria: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  criterion: { type: "string" },
+                  status: { type: "string", enum: ["PASS", "FAIL", "NOT TESTED"] },
+                  evidence: { type: "string", description: "Specific file:line, function name, issue number, or test name" },
                 },
+                required: ["criterion", "status", "evidence"],
               },
-              iteration_narrative: { type: "string", description: "Narrative describing each iteration: what happened, what changed, what the agent decided" },
-              scenario_summary: {
+              description: "Each acceptance criterion from MISSION.md verified against actual source code",
+            },
+            findings: {
+              type: "array",
+              items: {
                 type: "object",
                 properties: {
-                  total_iterations: { type: "number" },
-                  transforms: { type: "number" },
-                  convergence_iteration: { type: "number", description: "Which iteration reached mission-complete (0 if not reached)" },
-                  final_source_lines: { type: "number" },
-                  final_test_count: { type: "number" },
-                  acceptance_pass_count: { type: "string", description: "e.g. '7/8 PASS'" },
-                  total_tokens: { type: "number" },
+                  id: { type: "string", description: "FINDING-N" },
+                  title: { type: "string" },
+                  severity: { type: "string", enum: ["POSITIVE", "CONCERN", "CRITICAL", "REGRESSION", "OBSERVATION"] },
+                  description: { type: "string", description: "Include specific evidence: run IDs, issue numbers, file paths" },
                 },
+                required: ["id", "title", "severity", "description"],
               },
             },
-            required: ["summary", "findings", "recommendations"],
-          },
-          handler: async (args) => {
-            enrichedAnalysis = args;
-            return "Analysis recorded.";
+            recommendations: { type: "array", items: { type: "string" } },
           },
+          required: ["summary", "findings", "recommendations"],
         },
-      ];
-
-      const userPrompt = [
-        "Analyse the following mechanical benchmark data and produce an enriched report.",
-        "",
-        "You MUST:",
-        "1. Verify each acceptance criterion by reading the actual source code (use read_file).",
-        "2. For each workflow run, determine if it produced a transform (check merged PRs in the same time window).",
-        "3. Read issue bodies (use get_issue) to understand what work was requested and completed.",
-        "4. Produce a narrative timeline: for each iteration, what happened, what changed, what the agent decided.",
-        "5. Assess code quality by reading the source — is it clean, correct, well-tested?",
-        "",
-        "=== MECHANICAL DATA ===",
-        mechanicalReport,
-      ].join("\n");
+        handler: async (args) => {
+          analysis = args;
+          return { textResultForLlm: "Analysis recorded. The report will be generated from your findings." };
+        },
+      });
+
+      return [...ghTools, ...gitTools, reportTool];
+    };
 
+    const prompt = buildPrompt(summary, agentInstructions, repo);
+
+    const systemPrompt =
+      "You are a benchmark analyst for an autonomous coding pipeline. " +
+      "Your job is to investigate the gathered data using tools, verify acceptance criteria by reading source code, " +
+      "trace the transformation timeline from workflow runs to PRs to commits, " +
+      "and produce structured findings with specific evidence. " +
+      "Use read_file to examine source code, tests, and data files. " +
+      "Use list_issues and get_issue to understand work done. " +
+      "Call report_analysis exactly once with your complete analysis." +
+      NARRATIVE_INSTRUCTION;
+
+    try {
       const result = await runCopilotSession({
-        workspacePath: ".",
+        workspacePath: process.cwd(),
         model: model || config.model || "gpt-5-mini",
         tuning: config.tuning || {},
-        timeoutMs: 180000,
-        agentPrompt,
-        userPrompt,
-        tools,
+        agentPrompt: systemPrompt,
+        userPrompt: prompt,
+        writablePaths: [],
+        createTools,
+        excludedTools: ["write_file", "run_command", "run_tests"],
+        logger: { info: core.info, warning: core.warning, error: core.error, debug: core.debug },
       });
-      tokensUsed = result.tokensUsed || 0;
+      tokensUsed = result.tokensIn + result.tokensOut;
       resultModel = result.model || model;
+      core.info(`Report LLM session completed: ${tokensUsed} tokens`);
     } catch (err) {
-      core.warning(`LLM enrichment failed (report will be mechanical only): ${err.message}`);
+      core.warning(`LLM enrichment failed: ${err.message}`);
     }
   }
 
-  // Compose final report
-  let finalReport = mechanicalReport;
-  if (enrichedAnalysis) {
-    const enrichedSections = [];
-    enrichedSections.push(``);
-    enrichedSections.push(`---`);
-    enrichedSections.push(``);
-    enrichedSections.push(`## Analysis (LLM-enriched)`);
-    enrichedSections.push(``);
-    enrichedSections.push(enrichedAnalysis.summary || "");
-    enrichedSections.push(``);
-
-    if (enrichedAnalysis.iteration_narrative) {
-      enrichedSections.push(`### Iteration Narrative`);
-      enrichedSections.push(``);
-      enrichedSections.push(enrichedAnalysis.iteration_narrative);
-      enrichedSections.push(``);
-    }
-
-    if (enrichedAnalysis.acceptance_criteria?.length) {
-      enrichedSections.push(`### Acceptance Criteria`);
-      enrichedSections.push(``);
-      enrichedSections.push(`| Criterion | Status | Evidence |`);
-      enrichedSections.push(`|-----------|--------|----------|`);
-      for (const ac of enrichedAnalysis.acceptance_criteria) {
-        enrichedSections.push(`| ${ac.criterion} | ${ac.status} | ${ac.evidence} |`);
-      }
-      enrichedSections.push(``);
-    }
-
-    if (enrichedAnalysis.scenario_summary) {
-      const s = enrichedAnalysis.scenario_summary;
-      enrichedSections.push(`### Scenario Summary`);
-      enrichedSections.push(``);
-      enrichedSections.push(`| Metric | Value |`);
-      enrichedSections.push(`|--------|-------|`);
-      if (s.total_iterations != null) enrichedSections.push(`| Total iterations | ${s.total_iterations} |`);
-      if (s.transforms != null) enrichedSections.push(`| Transforms | ${s.transforms} |`);
-      if (s.convergence_iteration) enrichedSections.push(`| Convergence | Iteration ${s.convergence_iteration} |`);
-      if (s.final_source_lines) enrichedSections.push(`| Final source lines | ${s.final_source_lines} |`);
-      if (s.final_test_count) enrichedSections.push(`| Final test count | ${s.final_test_count} |`);
-      if (s.acceptance_pass_count) enrichedSections.push(`| Acceptance criteria | ${s.acceptance_pass_count} |`);
-      if (s.total_tokens) enrichedSections.push(`| Total tokens | ${s.total_tokens} |`);
-      enrichedSections.push(``);
-    }
-
-    if (enrichedAnalysis.findings?.length) {
-      enrichedSections.push(`### Findings`);
-      enrichedSections.push(``);
-      for (const f of enrichedAnalysis.findings) {
-        enrichedSections.push(`#### ${f.id}: ${f.title} (${f.severity})`);
-        enrichedSections.push(``);
-        enrichedSections.push(f.description);
-        enrichedSections.push(``);
-      }
-    }
-
-    if (enrichedAnalysis.recommendations?.length) {
-      enrichedSections.push(`### Recommendations`);
-      enrichedSections.push(``);
-      for (let i = 0; i < enrichedAnalysis.recommendations.length; i++) {
-        enrichedSections.push(`${i + 1}. ${enrichedAnalysis.recommendations[i]}`);
-      }
-      enrichedSections.push(``);
-    }
-
-    finalReport += enrichedSections.join("\n");
+  // Build final report
+  let finalReport;
+  if (analysis) {
+    finalReport = buildReportMarkdown(summary, analysis, repo, resultModel);
+  } else {
+    finalReport = buildFallbackReport(summary, repo);
   }
 
-  const narrative = `Generated benchmark report for ${repo.owner}/${repo.repo} covering ${periodStart} to ${periodEnd} (${workflowRuns.length} runs, ${commits.length} commits, ${issues.length} issues)`;
+  const narrative = `Generated benchmark report for ${repo.owner}/${repo.repo}: ${summary.workflowRunCount} runs, ${summary.transforms} transforms, mission ${summary.missionComplete ? "complete" : summary.missionFailed ? "failed" : "in progress"}`;
 
   return {
     outcome: "report-generated",

package/src/seeds/zero-package.json

@@ -17,7 +17,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@xn-intenton-z2a/agentic-lib": "^7.4.43"
+    "@xn-intenton-z2a/agentic-lib": "^7.4.44"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.0",