ai-agentmanager 1.9.0 → 1.10.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.10.0 (2026-10-31)
+
+- **Review scorecard:** an agent's changes scored 0-100 for Intent, Spec (each acceptance criterion met / not met / unverified, with evidence), Tests, Safety, Scope and Plan, with an overall readiness, a recommendation (Ready to approve / Look at these first / Not ready) and **Where to look**: the few hunks a person should read. Facts the app measures cap the model's scores (failing CI, failing checks, code without tests, plan steps ticked, unassessed criteria) and the recommendation follows fixed rules. At the top of Review changes, as a **Scorecard** document, as a badge in Land, in the PR description, and posted on the PR with **Post to PR** (posting again updates the comment). Runs by itself when the agent marks its work done (`"scorecard": { "auto": false }` turns that off); `agentmgr doc <agent> scorecard`.
+
 ## 1.9.0 (2026-10-31)
 
 - **Intent, spec and plan:** each task agent now has INTENT.md (the request as given, its Jira summary, attachments and who started it; written by AI Agent Manager), SPEC.md (requirements, acceptance criteria, out of scope; the agent writes it before changing code) and PLAN.md (steps it ticks off), next to its brief. **Intent · Spec · Plan** buttons and the split view's Docs menu show them; Explain, the documents and AI review read the spec and plan; **Push & open PR** puts them in the pull request's description (intent in full, spec and plan folded). `"specs": false` in config.json turns the spec and plan instructions off.

package/README.md

@@ -85,13 +85,13 @@ Runs on macOS and Linux; on Windows, use WSL2. Requires Node 20+, `git`, and the
 
 ```sh
 npm install -g ai-agentmanager          # the latest release
-npm install -g ai-agentmanager@1.9.0    # or a specific one
+npm install -g ai-agentmanager@1.10.0    # or a specific one
 ```
 
 Or from the repository, at a release tag:
 
 ```sh
-git clone --branch v1.9.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
+git clone --branch v1.10.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
 cd ai-agentmanager-core
 npm install
 npm link            # optional: puts `agentmgr` on your PATH
@@ -111,7 +111,7 @@ npm link
 | Installed with | Update |
 | --- | --- |
 | npm | `npm install -g ai-agentmanager@latest` |
-| A clone at a release tag | `git fetch --tags && git checkout v1.9.0 && npm install` (the tag you want) |
+| A clone at a release tag | `git fetch --tags && git checkout v1.10.0 && npm install` (the tag you want) |
 | A clone of `main` | `git pull && npm install` |
 
 **Check your setup.** `agentmgr doctor` checks Node.js, Claude Code and its sign-in, git, `gh`, the data folder, the daemon's port and Chrome, and says how to fix anything missing.
@@ -387,6 +387,7 @@ Each card has at most **three points of about 12 words each**, so they're easy t
 
 - **Files and diff.** The changed files on the left with lines added and removed, and the diff file by file on the right. Click a file header to fold it; very large files start folded.
 - **Line comments.** Click **+** next to a line (or its line number) to comment on it, and add an overall comment if you like. **Send to agent** types them into the agent as one message, each with its file, line and the code it is about, and asks it to address them. Comments not sent yet are kept in this browser.
+- **Review scorecard.** **📊 Score changes** (it also runs by itself when the agent marks its work done) scores the changes 0-100 for **Intent**, **Spec** (each acceptance criterion met, not met or unverified, with evidence), **Tests**, **Safety**, **Scope** and **Plan**, and gives an overall readiness with a recommendation: *Ready to approve*, *Look at these first* or *Not ready*, plus **Where to look**, the few hunks worth a person's time. What the app measures caps the model: failing CI or checks, code changed without tests, plan steps not ticked, criteria not assessed. **Post to PR** puts it on the pull request as a comment (again: updates it), and Push & open PR includes it in the description. It also shows as a badge in Land. Turn the automatic run off with `"scorecard": { "auto": false }`.
 - **Explain changes** explains each change one by one: a title, what it changes, why (from the request and the conversation), the risk and what to check, in the order a reviewer should read them. Each explanation sits above its hunk, and **◀ / ▶** (or **[** and **]**) step through them, opening folded files on the way. When the agent changes the code afterwards, the page says so and **Explain again** brings it up to date. From the CLI: `agentmgr doc <agent> walkthrough`.
 - **Commit all** commits everything in the worktree, new files included, with your git name and email.
 - **Intent, spec and plan.** Each agent keeps INTENT.md (what was asked, written by AI Agent Manager), SPEC.md (requirements and acceptance criteria, written by the agent before it changes code) and PLAN.md (steps, ticked off as it goes) next to its brief. Open them with **Intent · Spec · Plan** or in the split view's Docs; Explain, the documents and AI review read them too. `"specs": false` in config.json stops asking agents for the spec and plan.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Run background coding agents (Claude Code, Codex) per intent, and keep track of them from a web UI, your phone or the CLI",
   "keywords": [
     "claude",

package/public/app.js

@@ -7,6 +7,7 @@ import { openStream, post, REMOTE } from '/transport.js';
 import { attachBox } from '/attach.js';
 import { initSide } from '/side.js';
 import { addTools, download, htmlFile, initExport } from '/export.js';
+import { badgeHtml as scoreBadge, scorecardHtml, scorecardSpeech } from '/scorecard.js';
 import { bindListen, listenHtml, play, speakable, now as speaking, stop as stopSpeaking } from '/speak.js';
 import { initReview } from '/review.js';
 import { initLand, prChips } from '/land.js';
@@ -123,7 +124,7 @@ $('#new-playbook').onclick = () => {
   playbooksUi.open({ intent: f.intents.value.trim(), projects: f.project.value.trim() ? [f.project.value.trim()] : [], model: f.model.value.trim(), permissionMode: f.permissionMode.value });
 };
 $('#triggers-open').onclick = () => triggersUi.open();
-const landUi = initLand({ api, esc, toast, agents, $, select: (id) => (showTab('agents'), select(id)), openReview: (id) => reviewUi.open(id), isOpen: () => sideTab === 'land' });
+const landUi = initLand({ api, esc, toast, agents, $, scoreBadge, select: (id) => (showTab('agents'), select(id)), openReview: (id) => reviewUi.open(id), isOpen: () => sideTab === 'land' });
 
 function statusOf(a) {
   if (a.runtime.planning) return a.runtime.attention ? 'attention' : 'planning';
@@ -267,9 +268,9 @@ const INSIGHT_ICONS = { why: '🎯', what: '📦', how: '🛠', now: '📍' };
 
 // ------------------------------------------------------------------ stakeholder documents
 
-const DOCS = { analysis: 'Analysis', design: 'Design', flow: 'Flow', proposal: 'Proposal', humanai: 'Human vs AI', diagrams: 'Diagrams' };
+const DOCS = { analysis: 'Analysis', design: 'Design', flow: 'Flow', proposal: 'Proposal', humanai: 'Human vs AI', diagrams: 'Diagrams', scorecard: 'Scorecard' };
 // Optional extras that "Write all" leaves out.
-const DOC_EXTRAS = new Set(['diagrams']);
+const DOC_EXTRAS = new Set(['diagrams', 'scorecard']);
 const DOC_TITLES = { ...DOCS, plan: 'Plan', intent: 'Intent', spec: 'Spec' };
 // The agent's intent, spec and plan files (read from the daemon when opened; kept here by agent and kind).
 const SPEC_KINDS = { intent: 'Intent', spec: 'Spec', plan: 'Plan' };
@@ -350,7 +351,7 @@ function docButtons(a) {
       const d = a.docs?.[k];
       const stale = d?.markdown && a.brief?.updatedAt && d.briefUpdatedAt !== a.brief.updatedAt;
       return `<button class="small doc-btn ${d?.markdown ? 'has' : ''}" data-doc="${k}" ${d?.pending ? 'disabled' : ''}
-        title="${k === 'diagrams' ? (d?.markdown ? `Open the diagrams${stale ? ' (the brief changed since)' : ''}` : 'Draw the problem and its solution for a quick grasp: architecture, design, data flow (animated) and the key interaction, diagrams only. Built from the documents already written and the agent\'s work') : d?.markdown ? `Open the ${label.toLowerCase()} document${stale ? ' (the brief changed since)' : ''}` : `Write a ${label.toLowerCase()} document for stakeholders`}">${d?.pending ? `${label}…` : label}${d?.markdown ? (stale ? ' •' : ' ✓') : ''}</button>`;
+        title="${k === 'scorecard' ? (d?.markdown ? `Open the review scorecard: ${d.data?.overall ?? '—'}/100` : 'Score the changes for review: intent, spec, scope, plan, tests and safety, with an overall readiness and where to look') : k === 'diagrams' ? (d?.markdown ? `Open the diagrams${stale ? ' (the brief changed since)' : ''}` : 'Draw the problem and its solution for a quick grasp: architecture, design, data flow (animated) and the key interaction, diagrams only. Built from the documents already written and the agent\'s work') : d?.markdown ? `Open the ${label.toLowerCase()} document${stale ? ' (the brief changed since)' : ''}` : `Write a ${label.toLowerCase()} document for stakeholders`}">${d?.pending ? `${label}…` : label}${d?.markdown ? (stale ? ' •' : ' ✓') : ''}</button>`;
     })
     .join('')}</span>${specButtons(a)}`;
 }
@@ -388,7 +389,7 @@ function renderDocDialog() {
   else if (specKind && !d?.markdown) body.innerHTML = `<p class="hint">${docView.kind === 'intent' ? 'No intent file for this agent (agents created before 1.9 have none).' : `The agent hasn't written its ${label.toLowerCase()} yet. It writes ${docView.kind === 'spec' ? 'the spec before changing code' : 'the plan and keeps it current'}.`}</p>`;
   else if (d?.markdown) {
     if (body.dataset.rendered !== d.at) {
-      body.innerHTML = d.data ? humanAiHtml(d) : docHtml(d.markdown);
+      body.innerHTML = docView.kind === 'scorecard' ? scorecardHtml(d, esc) : d.data ? humanAiHtml(d) : docHtml(d.markdown);
       body.dataset.rendered = d.at;
       renderDiagrams(body);
     }
@@ -399,7 +400,7 @@ function renderDocDialog() {
   for (const id of ['doc-copy', 'doc-download', 'doc-print']) $(`#${id}`).disabled = !d?.markdown;
   // Diagrams: the whole document as one HTML file with every diagram (each also has Copy / PNG / SVG).
   $('#doc-html').hidden = !/```mermaid/.test(d?.markdown ?? '');
-  $('#doc-listen').innerHTML = d?.markdown && docView.kind !== 'diagrams' ? listenHtml(`doc:${docView.agentId}:${docView.kind}`, { title: 'Read the document aloud' }) : '';
+  $('#doc-listen').innerHTML = d?.markdown && docView.kind !== 'diagrams' ? listenHtml(docView.kind === 'scorecard' ? `score:${docView.agentId}` : `doc:${docView.agentId}:${docView.kind}`, { title: 'Read the document aloud' }) : '';
   $('#doc-print').hidden = plan || specKind;
   $('#doc-regen').hidden = plan || specKind;
   $('#doc-regen').disabled = Boolean(d?.pending);
@@ -538,6 +539,7 @@ bindListen((id) => {
   if (what === 'explain') parts = [speakable(a?.explanation?.markdown)];
   else if (what === 'doc') parts = [speakable(kind === 'explain' ? a?.explanation?.markdown : docOf(a, kind)?.markdown)];
   else if (what === 'walk') parts = reviewUi.listenParts();
+  else if (what === 'score') parts = a?.docs?.scorecard?.data ? scorecardSpeech(a.docs.scorecard) : null;
   else if (what === 'sidewalk') parts = sidePane?.listenParts();
   if (!parts?.length || !play(id, parts)) toast('Nothing to read aloud here (or this browser has no speech)');
 });

package/public/land.js

@@ -25,7 +25,7 @@ export function prChips(pr, esc) {
   return out.join(' ');
 }
 
-export function initLand({ api, esc, toast, agents, $, select, openReview, isOpen }) {
+export function initLand({ api, esc, toast, agents, $, scoreBadge = () => '', select, openReview, isOpen }) {
   const view = $('#land-view');
   let settings = null;
 
@@ -46,7 +46,7 @@ export function initLand({ api, esc, toast, agents, $, select, openReview, isOpe
       <div class="line1"><span class="prio p${a.priority ?? 2}">P${a.priority ?? 2}</span>
         <a class="name" href="${esc(pr.url)}" target="_blank" rel="noopener" title="${esc(pr.title ?? pr.url)}">#${esc(pr.number ?? '')} ${esc(pr.title ?? pr.url)}</a></div>
       <div class="line2"><button class="link" data-land="goto">${esc(a.name)}</button>${a.runtime?.busy ? ' <span class="hint">working</span>' : ''}</div>
-      <div class="land-chips">${prChips(pr, esc)}</div>
+      <div class="land-chips">${scoreBadge(a.docs?.scorecard, esc)} ${prChips(pr, esc)}</div>
       <div class="bl-actions">
         <button class="small" data-land="review" title="Its diff, line comments for the agent, commit and push">Review</button>
         ${land === 'behind' || pr.mergeable === 'CONFLICTING' ? '<button class="small" data-land="update" title="Merge the base branch in here (when the agent is idle and its work is committed) and push; otherwise, or on conflicts, ask the agent">Update</button>' : ''}

package/public/review.js

@@ -3,6 +3,7 @@
 // With a walkthrough, each hunk shows its explanation and ◀ / ▶ step through them in reading order.
 import { cardHtml, explainButton, listenParts as walkParts, stepOf, walkthroughOf } from './walkthrough.js';
 import { listenHtml, now as speaking, stop as stopSpeaking } from './speak.js';
+import { scorecardHtml, scorecardOf } from './scorecard.js';
 
 /** Unified diff -> [{ path, status, binary, hunks: [{ head, lines: [{ t, old, new, text }] }] }] */
 export function parseDiff(text) {
@@ -138,7 +139,7 @@ export function initReview({ api, esc, toast, agents, $ }) {
     for (const h of f.hunks) {
       const i = w.doc ? stepOf(w.doc, f.path, h.head) : -1;
       if (i >= 0) rows.push(`<tr class="rv-explain ${st.step === i ? 'current' : ''}" id="rv-step-${i}"><td colspan="3">${cardHtml(w.doc.data.changes[i], i, w.doc.data.changes.length, esc)}</td></tr>`);
-      rows.push(`<tr class="rv-hunk"><td colspan="3">${esc(h.head)}</td></tr>`);
+      rows.push(`<tr class="rv-hunk" data-rv-hunk="${esc(`${f.path}\t${h.head}`)}"><td colspan="3">${esc(h.head)}</td></tr>`);
       for (const l of h.lines) {
         const side = l.t === 'del' ? 'old' : 'new';
         const line = side === 'old' ? l.old : l.new;
@@ -157,6 +158,32 @@ export function initReview({ api, esc, toast, agents, $ }) {
     return `<div class="rv-file" id="rv-${encodeURIComponent(f.path)}">${head}<table class="rv-table">${rows.join('')}</table></div>`;
   }
 
+  /** The review scorecard at the top: scores, verdict and where to look, or the button to score. */
+  function scorePanel() {
+    if (!st.data?.files.length) return '';
+    const sc = scorecardOf(agents.get(st.id), st.data.diffHash);
+    const openPr = st.data.prs.find((p) => p.state === 'OPEN');
+    const run = `<button type="button" class="small ${sc.doc && !sc.stale ? 'ghost' : 'primary'}" data-sc-run ${sc.pending ? 'disabled' : ''} title="Score the changes against the intent, spec, plan and tests, with where to look (a separate one-off call)">${sc.pending ? 'Scoring…' : sc.doc ? (sc.stale ? 'Score again (changed)' : 'Score again') : '📊 Score changes'}</button>`;
+    if (!sc.doc) {
+      return `<div class="rv-score-empty">${run}<span class="hint">${sc.error && !sc.pending ? `<span class="error">Couldn't score: ${esc(sc.error)}</span>` : 'Scores against the intent, spec, scope, plan, tests and safety, with an overall readiness and the few places to read.'}</span></div>`;
+    }
+    const post = openPr ? `<button type="button" class="small ghost" data-sc-post title="Post the scorecard on the pull request as a comment (posting again updates it)">${sc.doc.postedTo === openPr.url ? 'Update on PR' : 'Post to PR'}</button>` : '';
+    return `<div class="rv-score">${scorecardHtml(sc.doc, esc, { stale: sc.stale, actions: `${listenHtml(`score:${st.id}`, { title: 'Hear the scorecard' })}${post}${run}` })}</div>`;
+  }
+
+  /** Open the file of a hunk (from "where to look") and scroll to it. */
+  function gotoHunk(key) {
+    const [file] = key.split('\t');
+    st.collapsed.delete(file);
+    keepInputs();
+    render();
+    const row = [...body.querySelectorAll('[data-rv-hunk]')].find((r) => r.dataset.rvHunk === key);
+    if (!row) return toast('That part of the change has moved since it was scored');
+    row.scrollIntoView({ block: 'center', behavior: 'smooth' });
+    row.classList.add('flash');
+    setTimeout(() => row.classList.remove('flash'), 1600);
+  }
+
   /** Explain changes, then ◀ n of N ▶ once there is a walkthrough. */
   function walkNav() {
     const w = walk();
@@ -221,6 +248,7 @@ export function initReview({ api, esc, toast, agents, $ }) {
         ${d.files.length ? walkNav() : ''}
         <button type="button" class="small ghost" data-rv-reload>${st.loading ? 'Loading…' : 'Reload'}</button>
       </div>
+      ${scorePanel()}
       ${walkNote()}
       ${d.busy ? '<p class="hint rv-warn">The agent is working, so the changes may still move. Reload when it is idle.</p>' : ''}
       ${d.truncated ? '<p class="hint rv-warn">The diff is large and was cut short; open a shell for the rest.</p>' : ''}
@@ -289,6 +317,29 @@ export function initReview({ api, esc, toast, agents, $ }) {
     if (t.closest('[data-rv-reload]')) return keepInputs(), reload();
     const stepBtn = t.closest('[data-rv-step]');
     if (stepBtn) return step(Number(stepBtn.dataset.rvStep));
+    const look = t.closest('[data-sc-look]');
+    if (look) return gotoHunk(look.dataset.scLook);
+    if (t.closest('[data-sc-run]')) {
+      keepInputs();
+      try {
+        agents.set(st.id, await api('POST', `/agents/${st.id}/docs/scorecard?background=1`));
+        render();
+      } catch (err) {
+        toast(`Error: ${err.message}`, 5000);
+      }
+      return;
+    }
+    if (t.closest('[data-sc-post]')) {
+      t.disabled = true;
+      try {
+        const r = await api('POST', `/agents/${st.id}/scorecard/post`);
+        toast(r.edited ? 'Scorecard updated on the pull request' : 'Scorecard posted on the pull request', 4000, { label: 'Open', run: () => window.open(r.url, '_blank', 'noopener') });
+      } catch (err) {
+        toast(`Error: ${err.message}`, 6000);
+      }
+      t.disabled = false;
+      return;
+    }
     if (t.closest('[data-rv-explain]')) {
       keepInputs();
       try {
@@ -442,7 +493,8 @@ export function initReview({ api, esc, toast, agents, $ }) {
   function agentChanged(a) {
     if (!dlg.open || a.id !== st.id || !st.data) return;
     const w = a.docs?.walkthrough;
-    const sig = `${w?.at}|${w?.pending}|${w?.error}`;
+    const sc = a.docs?.scorecard;
+    const sig = `${w?.at}|${w?.pending}|${w?.error}|${sc?.at}|${sc?.pending}|${sc?.error}|${sc?.postedTo}`;
     if (sig === st.walkSig) return;
     st.walkSig = sig;
     keepInputs();

package/public/scorecard.js

@@ -0,0 +1,68 @@
+// The review scorecard on the page: an overall readiness, a bar per score with why, the acceptance
+// criteria, and where to look. Shared by Review changes, the Scorecard document and Land's badges.
+
+const DIMENSIONS = [
+  ['intent', 'Intent'],
+  ['spec', 'Spec'],
+  ['tests', 'Tests'],
+  ['safety', 'Safety'],
+  ['scope', 'Scope'],
+  ['plan', 'Plan'],
+];
+export const RECOMMENDATION = { ready: 'Ready to approve', look: 'Look at these first', not_ready: 'Not ready' };
+const tone = (n) => (n == null ? '' : n >= 80 ? 'good' : n >= 50 ? 'mid' : 'bad');
+const recTone = { ready: 'good', look: 'mid', not_ready: 'bad' };
+
+/** The scorecard of an agent and whether it still matches the changes (diffHash from /changes). */
+export function scorecardOf(agent, diffHash) {
+  const d = agent?.docs?.scorecard;
+  return { doc: d?.data ? d : null, pending: Boolean(d?.pending), error: d?.error ?? null, stale: Boolean(d?.data && diffHash && d.diffHash !== diffHash) };
+}
+
+/** A small badge: "82 · Ready to approve". */
+export function badgeHtml(doc, esc) {
+  if (!doc?.data) return '';
+  const sc = doc.data;
+  return `<span class="sc-badge ${recTone[sc.recommendation]}" title="Review scorecard: ${esc(RECOMMENDATION[sc.recommendation])}${sc.reasons.length ? ` (${esc(sc.reasons.join('; '))})` : ''}">${sc.overall ?? '—'} · ${esc(RECOMMENDATION[sc.recommendation])}</span>`;
+}
+
+/**
+ * The full card. `actions` is extra HTML for the head (buttons); look items carry
+ * data-sc-look="<file>\t<head>" for the page to jump to.
+ */
+export function scorecardHtml(doc, esc, { stale = false, actions = '' } = {}) {
+  const sc = doc.data;
+  const rows = DIMENSIONS.map(([k, label]) => {
+    const d = sc.scores[k];
+    if (!d) return `<div class="sc-row na"><span class="sc-label">${label}</span><span class="sc-bar"></span><span class="sc-n">—</span><span class="sc-why hint">${k === 'spec' ? 'No spec written' : 'Not scored'}</span></div>`;
+    return `<div class="sc-row"><span class="sc-label">${label}</span><span class="sc-bar"><span class="${tone(d.score)}" style="width:${d.score}%"></span></span><span class="sc-n">${d.score}</span><span class="sc-why">${esc(d.why)}${d.notes.length ? ` <span class="sc-note">${esc(d.notes.join('; '))}</span>` : ''}</span></div>`;
+  }).join('');
+  const crit = sc.criteria.length
+    ? `<details class="sc-crit" ${sc.criteria.some((c) => c.status !== 'met') ? 'open' : ''}><summary>Acceptance criteria: ${sc.criteria.filter((c) => c.status === 'met').length} of ${sc.criteria.length} met</summary><ul>${sc.criteria.map((c) => `<li class="${c.status}"><span class="sc-mark">${c.status === 'met' ? '✓' : c.status === 'not_met' ? '✗' : '?'}</span>${esc(c.criterion)}${c.evidence ? ` <span class="hint">${esc(c.evidence)}</span>` : ''}</li>`).join('')}</ul></details>`
+    : '';
+  const look = sc.look.length
+    ? `<div class="sc-look"><b>Where to look</b><ol>${sc.look.map((l) => `<li><button type="button" class="link" data-sc-look="${esc(`${l.file}\t${l.head}`)}"><code>${esc(l.file)}</code></button> ${esc(l.reason)}</li>`).join('')}</ol></div>`
+    : '';
+  const f = sc.facts;
+  return `<div class="scorecard">
+    <div class="sc-head">
+      <span class="sc-overall ${recTone[sc.recommendation]}"><b>${sc.overall ?? '—'}</b><small>/100</small></span>
+      <div class="sc-verdict"><b>${esc(RECOMMENDATION[sc.recommendation])}</b>${sc.reasons.length ? `<div class="hint">${esc(sc.reasons.join(' · '))}</div>` : ''}<div class="hint">${esc(sc.summary)}</div></div>
+      <span class="spacer"></span>${actions}
+    </div>
+    ${stale ? '<p class="hint sc-stale"><b>The changes moved since this was scored.</b> Score again for the latest.</p>' : ''}
+    <div class="sc-rows">${rows}</div>
+    ${crit}${look}
+    <div class="hint sc-facts">Measured: ${f.files} files (+${f.added} −${f.removed}) · ${f.testFiles} test files · CI ${esc(f.ci ?? 'n/a')} · checks ${f.checks.passed}✓ ${f.checks.failed}✗${f.plan ? ` · plan ${f.plan.done}/${f.plan.steps}` : ''}${doc.writer ? ` · scored by ${esc(doc.writer)}` : ''}</div>
+  </div>`;
+}
+
+/** What Listen reads: the verdict, then each score with why. */
+export function scorecardSpeech(doc) {
+  const sc = doc.data;
+  return [
+    `${RECOMMENDATION[sc.recommendation]}. Overall ${sc.overall ?? 'not scored'} out of 100. ${sc.reasons.join('. ')} ${sc.summary}`,
+    ...DIMENSIONS.filter(([k]) => sc.scores[k]).map(([k, label]) => `${label}: ${sc.scores[k].score}. ${sc.scores[k].why} ${sc.scores[k].notes.join('. ')}`),
+    ...(sc.look.length ? [`Where to look: ${sc.look.map((l) => `${l.file.split('/').pop()}: ${l.reason}`).join('. ')}`] : []),
+  ];
+}

package/public/style.css

@@ -906,3 +906,31 @@ form.dropping { outline: 2px dashed var(--accent, #6b8cff); outline-offset: 4px;
 .say.on button:first-child { min-width: 30px; }
 .explain-foot { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
 .sd-step.current { box-shadow: 0 0 0 2px var(--accent, #6b8cff); }
+
+/* Review scorecard. */
+.scorecard { display: flex; flex-direction: column; gap: 8px; padding: 10px 12px; border: 1px solid var(--border); border-radius: 8px; background: var(--panel); }
+.sc-head { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
+.sc-overall { display: flex; align-items: baseline; gap: 2px; padding: 4px 10px; border-radius: 8px; border: 2px solid currentColor; }
+.sc-overall b { font-size: 26px; line-height: 1; }
+.sc-overall small { opacity: .7; }
+.sc-verdict { min-width: 0; flex: 1 1 260px; }
+.good { color: var(--green); } .mid { color: var(--yellow); } .bad { color: var(--red); }
+.sc-rows { display: flex; flex-direction: column; gap: 4px; }
+.sc-row { display: grid; grid-template-columns: 64px 140px 32px 1fr; gap: 8px; align-items: center; font-size: 13px; }
+.sc-label { font-weight: 600; }
+.sc-bar { height: 8px; border-radius: 4px; background: var(--panel-2); overflow: hidden; }
+.sc-bar > span { display: block; height: 100%; background: currentColor; }
+.sc-n { text-align: right; font-variant-numeric: tabular-nums; }
+.sc-note { color: var(--yellow); }
+.sc-row.na { opacity: .6; }
+.sc-crit ul, .sc-look ol { margin: 4px 0 0; padding-left: 20px; }
+.sc-crit li { list-style: none; margin-left: -16px; }
+.sc-mark { display: inline-block; width: 16px; font-weight: 700; }
+.sc-crit li.met .sc-mark { color: var(--green); } .sc-crit li.not_met .sc-mark { color: var(--red); } .sc-crit li.unverified .sc-mark { color: var(--yellow); }
+.sc-facts { font-size: 11.5px; }
+.sc-badge { display: inline-block; padding: 1px 8px; border-radius: 999px; border: 1px solid currentColor; font-size: 12px; white-space: nowrap; }
+.rv-score { margin: 0 12px 8px; }
+.rv-score-empty { display: flex; align-items: center; gap: 10px; margin: 0 12px 8px; }
+.rv-hunk.flash td { animation: rvflash 1.6s; }
+@keyframes rvflash { 0%, 60% { background: var(--accent); color: var(--accent-text); } }
+@media (max-width: 640px) { .sc-row { grid-template-columns: 56px 1fr 28px; } .sc-why { grid-column: 1 / -1; } }

package/src/cli.js

@@ -430,9 +430,9 @@ export async function main(argv) {
 
   program
     .command('doc')
-    .description('Write a stakeholder document from the agent work: analysis, design, flow, proposal, humanai (Human vs AI), diagrams (diagrams only) or walkthrough (its changes explained one by one)')
+    .description('Write a stakeholder document from the agent work: analysis, design, flow, proposal, humanai (Human vs AI), diagrams (diagrams only), walkthrough (its changes explained one by one) or scorecard (its changes scored for review)')
     .argument('<agent>')
-    .argument('<kind>', 'analysis, design, flow, proposal, humanai, diagrams, walkthrough, or all (background; diagrams and walkthrough not included)')
+    .argument('<kind>', 'analysis, design, flow, proposal, humanai, diagrams, walkthrough, scorecard, or all (background; diagrams, walkthrough and scorecard not included)')
     .option('-o, --output <file>', 'also save the Markdown to this file')
     .option('--cached', 'print the last version instead of writing a new one')
     .option('-b, --background', 'start writing and return at once (kind "all" writes all five)')

package/src/manager.js

@@ -47,6 +47,7 @@ const SUMMARIES = {
   humanai: { doc: 'humanai', run: 'runHumanAi' },
   diagrams: { doc: 'diagrams', run: 'runDiagrams' },
   walkthrough: { doc: 'walkthrough', run: 'runWalkthrough' },
+  scorecard: { doc: 'scorecard', run: 'runScorecard' },
 };
 /** Read / write where a summary of `kind` is kept on the agent record. */
 const getSummary = (agent, kind) => (SUMMARIES[kind].doc ? agent.docs?.[kind] : agent[SUMMARIES[kind].field]);
@@ -100,6 +101,7 @@ import { spawn } from 'node:child_process';
 import * as git from './git.js';
 import { parseDiff } from '../public/review.js';
 import { issueSummary, leadingIssue, wordsAfterLink } from './jira.js';
+import { combine, facts as scoreFacts, scorecardMarkdown, scorecardPrompt } from './scorecard.js';
 import { conflictMessage, findConflicts, related, repoKey, summarize as summarizeConflicts } from './conflicts.js';
 import { answerMessage, loadQuestions, questionsPath, questionsPrompt } from './inbox.js';
 import { STUCK_DEFAULTS, detectStuck } from './stuck.js';
@@ -1887,6 +1889,8 @@ export class AgentManager extends EventEmitter {
       this.patch(id, { brief });
       // The agent says it is done: have the judge check the work before the person looks.
       if (brief.status === 'done' && agent.brief?.status !== 'done' && this.judge.enabled) this.requestReview(id, { trigger: 'brief' }).catch(() => {});
+      // ...and score it for the reviewer ("scorecard": { "auto": false } in config.json turns this off).
+      if (brief.status === 'done' && agent.brief?.status !== 'done' && this.config.scorecard?.auto !== false && !NO_REPO.has(agent.kind) && this.changesSource) this.summarize(id, 'scorecard').catch(() => {});
     }
     if (agent.planReview) {
       const file = loadPlanFile(id, agent.planReview);
@@ -2136,6 +2140,42 @@ export class AgentManager extends EventEmitter {
     );
   }
 
+  /**
+   * The review scorecard (see scorecard.js): the same diff the review screen shows, scored against
+   * the intent, spec and plan, with the facts the app measures capping what the model says.
+   */
+  async runScorecard(agent, ctx) {
+    if (!this.changesSource) throw new Error('Changes are not available here');
+    const data = await this.changesSource(agent.id);
+    const { hunks, cut } = walkthroughHunks(parseDiff(data.diff), { maxChars: 50_000 });
+    if (!hunks.length) throw Object.assign(new Error('No changes to score yet'), { status: 400 });
+    const cur0 = this.store.get(agent.id) ?? agent;
+    const doc = (n) => readSpecDoc(agent.id, n)?.markdown ?? '';
+    const f = scoreFacts({ files: data.files, prs: Object.values(cur0.prs ?? {}), brief: cur0.brief, plan: doc('plan'), spec: doc('spec') });
+    const writer = this.writerFor(agent);
+    const prompt = scorecardPrompt({ ...ctx, briefMarkdown: this.briefFile(agent.id).markdown ?? '', intentDoc: doc('intent'), specDoc: doc('spec'), planDoc: doc('plan'), hunks, facts: f });
+    const sc = combine(parseJsonReply(await this.oneShot(agent, prompt, writer)), f, hunks);
+    const cur = this.store.get(agent.id);
+    if (!cur) return null;
+    return this.view(
+      this.patch(
+        agent.id,
+        summaryPatch(cur, 'scorecard', {
+          data: sc,
+          cut,
+          diffHash: hash(data.diff),
+          markdown: scorecardMarkdown(sc, cur.name),
+          writer: `${writer.engine.label}${writer.model ? ` (${writer.model})` : ''}`,
+          postedTo: cur.docs?.scorecard?.postedTo ?? null,
+          at: now(),
+          briefUpdatedAt: cur.brief?.updatedAt ?? null,
+          pending: false,
+          error: null,
+        }),
+      ),
+    );
+  }
+
   /** Diagrams only: the problem and its solution drawn from the documents already written and the live context. */
   async runDiagrams(agent, ctx) {
     const cur0 = this.store.get(agent.id) ?? agent;

package/src/review.js

@@ -143,6 +143,32 @@ export class Review {
     };
   }
 
+  /**
+   * Post the review scorecard on the agent's open pull request as a comment, so approvers see it in
+   * GitHub. Posting again edits the last comment instead of adding another.
+   */
+  async postScorecard(ref) {
+    const agent = this.agentWithRepo(ref);
+    const sc = agent.docs?.scorecard;
+    if (!sc?.markdown) throw err(409, 'Score the changes first');
+    const pr = Object.values(agent.prs ?? {}).find((p) => p.state === 'OPEN');
+    if (!pr) throw err(409, 'No open pull request for this agent');
+    this.manager.plugins.check('agent.pr', { agent: this.manager.auditView(agent), title: 'scorecard comment', draft: false });
+    const opts = { cwd: agent.workdir, timeout: 60_000 };
+    const args = ['pr', 'comment', pr.url, '--body', sc.markdown];
+    const again = sc.postedTo === pr.url;
+    try {
+      await git.run(ghBin(), again ? [...args, '--edit-last'] : args, opts);
+    } catch (e) {
+      // The comment we edited may be gone; add a new one.
+      if (!again) throw err(502, `Posting the scorecard failed: ${e.message.replace(/^gh .*? failed: /, '')}`);
+      await git.run(ghBin(), args, opts);
+    }
+    const cur = this.manager.store.get(agent.id);
+    this.manager.patch(agent.id, { docs: { ...cur.docs, scorecard: { ...cur.docs.scorecard, postedTo: pr.url, postedAt: new Date().toISOString() } } });
+    return { url: pr.url, edited: again };
+  }
+
   /** Send the comments to the agent as one message (typed in when it is idle). */
   comment(ref, { comments = [], note = '' } = {}) {
     const agent = this.agentWithRepo(ref);
@@ -194,8 +220,14 @@ export class Review {
     }
     const args = ['pr', 'create', '--head', branch];
     if (target) args.push('--base', target);
-    // The description: your text (else the commits), then the intent, spec and plan.
-    const sections = prSections(agent.id);
+    // The description: your text (else the commits), the review scorecard, then the intent, spec and plan.
+    const sc = agent.docs?.scorecard;
+    let card = '';
+    if (sc?.markdown) {
+      const now = base ? hash(await git.fullDiff(dir, base.sha)) : null;
+      card = sc.diffHash && now && sc.diffHash !== now ? `${sc.markdown}\n\n<sub>Scored before the latest changes.</sub>` : sc.markdown;
+    }
+    const sections = [card, prSections(agent.id)].filter(Boolean).join('\n\n');
     if (String(title).trim() || sections) {
       const log = base ? await git.run('git', ['log', '--reverse', '--format=%s', `${base.sha}..HEAD`], opts).catch(() => '') : '';
       const subjects = log.split('\n').filter(Boolean);

package/src/scorecard.js

@@ -0,0 +1,189 @@
+// The review scorecard: an agent's changes scored against what was asked (intent), what done means
+// (spec), staying on task (scope), its plan, the tests and safety, with an overall readiness and the
+// few places a person should actually read. A model judges; facts the app measures (CI, test files,
+// plan ticks, the spec's criteria) cap and correct it, and the recommendation follows fixed rules,
+// so a confident-sounding model can't talk a change into "ready".
+
+export const DIMENSIONS = [
+  ['intent', 'Intent', 'Does it do what was asked?'],
+  ['spec', 'Spec', 'Are the acceptance criteria met?'],
+  ['tests', 'Tests', 'Is it verified: CI, tests for the changed code, checks run?'],
+  ['safety', 'Safety', 'Risky areas handled: security, data, migrations, dependencies, public APIs (higher is safer)'],
+  ['scope', 'Scope', 'Only what the task needs, in proportion?'],
+  ['plan', 'Plan', 'Done as planned, departures explained?'],
+];
+const WEIGHTS = { intent: 25, spec: 20, tests: 20, safety: 15, scope: 10, plan: 10 };
+const TEST_FILE = /(^|\/)(tests?|__tests__|spec|specs)\/|[._-](test|spec)\.[a-z]+$|_test\.go$|Test\.java$/i;
+
+/** Facts the app knows without a model: CI, test files touched, the agent's checks, plan and spec progress. */
+export function facts({ files = [], prs = [], brief = null, plan = '', spec = '' }) {
+  const paths = files.map((f) => f.path);
+  const tests = paths.filter((p) => TEST_FILE.test(p));
+  const code = paths.filter((p) => !TEST_FILE.test(p) && !/\.(md|txt|rst|adoc)$/i.test(p) && !/(^|\/)docs?\//i.test(p));
+  const open = prs.find((p) => p.state === 'OPEN') ?? prs[0];
+  const checks = brief?.checks ?? [];
+  const count = (st) => checks.filter((c) => c.state === st).length;
+  const steps = [...String(plan).matchAll(/^\s*[-*]\s+\[([ xX~!])\]/gm)].map((m) => m[1].toLowerCase());
+  const criteriaBlock = /^##\s*Acceptance criteria\s*$([\s\S]*?)(?=^##\s|(?![\s\S]))/im.exec(String(spec))?.[1] ?? '';
+  return {
+    files: paths.length,
+    added: files.reduce((s, f) => s + (f.added ?? 0), 0),
+    removed: files.reduce((s, f) => s + (f.removed ?? 0), 0),
+    testFiles: tests.length,
+    codeFiles: code.length,
+    ci: open?.checks?.state ?? null, // passed | failed | running | null (no PR or no checks)
+    ciFailed: open?.checks?.failed ?? [],
+    checks: { passed: count('passed'), failed: count('failed'), pending: count('pending') + count('running') },
+    plan: steps.length ? { steps: steps.length, done: steps.filter((s) => s === 'x').length } : null,
+    criteria: criteriaBlock.split('\n').filter((l) => /^\s*[-*\d]/.test(l) && /\w/.test(l)).length,
+    hasSpec: Boolean(String(spec).trim()),
+  };
+}
+
+const factLines = (f) =>
+  [
+    `files changed: ${f.files} (+${f.added} -${f.removed}); code files: ${f.codeFiles}; test files: ${f.testFiles}`,
+    `CI on the pull request: ${f.ci ?? 'no pull request or no checks yet'}${f.ciFailed.length ? ` (failing: ${f.ciFailed.join(', ')})` : ''}`,
+    `the agent's own checks (from its brief): ${f.checks.passed} passed, ${f.checks.failed} failed, ${f.checks.pending} pending`,
+    `plan: ${f.plan ? `${f.plan.done} of ${f.plan.steps} steps ticked` : 'no plan written'}`,
+    `spec: ${f.hasSpec ? `${f.criteria} acceptance criteria` : 'no spec written'}`,
+  ].join('\n');
+
+export function scorecardPrompt({ intent, status, digest, briefMarkdown, intentDoc, specDoc, planDoc, hunks, facts: f }) {
+  return [
+    "You score an AI coding agent's changes for a reviewer who wants to approve with confidence and read as little as possible.",
+    'Be skeptical: a claim without evidence in the diff, the tests or the checks counts as unverified. Base everything on the material below.',
+    '',
+    'Reply with one JSON object only:',
+    '{"summary": "<two sentences: what the change does and how sure you are>",',
+    ' "scores": {"intent": {"score": 0-100, "why": "<one sentence>"}, "scope": {...}, "plan": {...}, "tests": {...}, "safety": {...}},',
+    ' "criteria": [{"criterion": "<an acceptance criterion from the spec>", "status": "met|not_met|unverified", "evidence": "<where: file, test, check>"}],',
+    ' "look": [{"id": "H3", "reason": "<why a person should read this hunk>"}]}',
+    '',
+    'Scoring (100 is best; be calibrated, not generous):',
+    '- intent: how fully the change does what INTENT asks. Missing parts of the ask pull it down hard.',
+    '- scope: 100 when every change serves the task; lower for unrelated edits, drive-by refactors, or a change far larger than the task needs.',
+    '- plan: how closely the change follows PLAN (steps done, departures explained). Without a plan, judge whether the work is coherent.',
+    '- tests: whether the changed behavior is verified: tests added or updated for it, CI, checks the agent ran. Code changes with no tests and no passing checks score low.',
+    '- safety: 100 when nothing risky is touched or risks are handled; lower for security, auth, data loss, migrations, concurrency, money, new dependencies or public API changes without care.',
+    '- criteria: one entry per acceptance criterion in SPEC, in its order; leave the list empty if there is no spec.',
+    '- look: at most 5 hunks a person must read (the risky, subtle or unverified ones), most important first. Not the obvious ones.',
+    '',
+    '<facts_measured_by_the_app>',
+    factLines(f),
+    '</facts_measured_by_the_app>',
+    '<intent>',
+    intentDoc || intent || '(none)',
+    '</intent>',
+    '<spec>',
+    specDoc || '(no spec written)',
+    '</spec>',
+    '<plan>',
+    planDoc || '(no plan written)',
+    '</plan>',
+    '<agent_status>',
+    status,
+    '</agent_status>',
+    '<conversation>',
+    (digest || '(none)').slice(-12_000),
+    '</conversation>',
+    '<brief>',
+    briefMarkdown || '(none)',
+    '</brief>',
+    '<hunks>',
+    ...hunks.map((h) => `<hunk id="${h.id}" file="${h.file}">\n${h.head}\n${h.text}\n</hunk>`),
+    '</hunks>',
+  ].join('\n');
+}
+
+const clamp = (n) => Math.max(0, Math.min(100, Math.round(Number(n) || 0)));
+
+/**
+ * The scorecard from the model's reply and the facts: scores capped by what was measured, the spec
+ * score computed from the criteria, the overall weighted, and a recommendation by rule.
+ */
+export function combine(reply, f, hunks) {
+  const s = reply?.scores ?? {};
+  const score = (k) => (s[k] && Number.isFinite(Number(s[k].score)) ? { score: clamp(s[k].score), why: String(s[k].why ?? '').slice(0, 300), notes: [] } : null);
+  const out = { intent: score('intent'), scope: score('scope'), plan: score('plan'), tests: score('tests'), safety: score('safety'), spec: null };
+  const cap = (k, max, note) => {
+    if (out[k] && out[k].score > max) {
+      out[k].score = max;
+      out[k].notes.push(note);
+    }
+  };
+  // Tests: failing CI or failing checks, or code changed with nothing verifying it.
+  if (f.ci === 'failed') cap('tests', 30, `CI is failing${f.ciFailed.length ? ` (${f.ciFailed.join(', ')})` : ''}`);
+  if (f.checks.failed) cap('tests', 40, `${f.checks.failed} of the agent's checks failed`);
+  if (f.codeFiles && !f.testFiles && !f.checks.passed && f.ci !== 'passed') cap('tests', 45, 'code changed with no tests and no passing checks');
+  // Plan: bounded by the steps ticked.
+  if (f.plan && out.plan) cap('plan', Math.round(40 + (60 * f.plan.done) / f.plan.steps), `${f.plan.done} of ${f.plan.steps} plan steps ticked`);
+  if (!f.plan && out.plan) out.plan.notes.push('no plan written');
+  // Spec: computed from the criteria (met 1, unverified ½, not met 0); none without a spec.
+  const criteria = (Array.isArray(reply?.criteria) ? reply.criteria : [])
+    .filter((c) => c?.criterion)
+    .slice(0, 20)
+    .map((c) => ({ criterion: String(c.criterion).slice(0, 300), status: ['met', 'not_met', 'unverified'].includes(c.status) ? c.status : 'unverified', evidence: String(c.evidence ?? '').slice(0, 300) }));
+  // A spec with criteria the model didn't assess: they count as unverified, not as passed.
+  if (f.hasSpec && f.criteria && !criteria.length) out.spec = { score: 50, why: `${f.criteria} acceptance criteri${f.criteria === 1 ? 'on' : 'a'} not assessed`, notes: ['treated as unverified'] };
+  if (f.hasSpec && criteria.length) {
+    const pts = criteria.reduce((n, c) => n + (c.status === 'met' ? 1 : c.status === 'unverified' ? 0.5 : 0), 0);
+    const met = criteria.filter((c) => c.status === 'met').length;
+    out.spec = { score: clamp((100 * pts) / criteria.length), why: `${met} of ${criteria.length} acceptance criteri${criteria.length === 1 ? 'on' : 'a'} met${criteria.some((c) => c.status === 'not_met') ? ', some not met' : ''}`, notes: [] };
+  }
+  // Overall: weighted over the scores there are.
+  const have = Object.entries(WEIGHTS).filter(([k]) => out[k]);
+  const total = have.reduce((n, [, w]) => n + w, 0);
+  const overall = total ? Math.round(have.reduce((n, [k, w]) => n + out[k].score * w, 0) / total) : null;
+  const notMet = criteria.filter((c) => c.status === 'not_met');
+  const reasons = [];
+  if (f.ci === 'failed') reasons.push('CI is failing');
+  if (notMet.length) reasons.push(`${notMet.length} acceptance criteri${notMet.length === 1 ? 'on' : 'a'} not met`);
+  if (out.intent && out.intent.score < 50) reasons.push('it does not do enough of what was asked');
+  if (out.tests && out.tests.score < 40 && f.ci !== 'failed') reasons.push('it is barely verified');
+  let recommendation;
+  if (reasons.length) recommendation = 'not_ready';
+  else if (overall != null && overall >= 80 && (out.tests?.score ?? 0) >= 70 && (out.safety?.score ?? 100) >= 70 && (out.spec?.score ?? 100) >= 70 && f.ci !== 'running') recommendation = 'ready';
+  else recommendation = 'look';
+  // Where to look, mapped back to hunks.
+  const byId = new Map(hunks.map((h) => [h.id, h]));
+  const look = (Array.isArray(reply?.look) ? reply.look : [])
+    .map((l) => ({ h: byId.get(String(l?.id ?? '').trim()), reason: String(l?.reason ?? '').slice(0, 300) }))
+    .filter((l) => l.h)
+    .slice(0, 5)
+    .map(({ h, reason }) => ({ file: h.file, head: h.head, reason }));
+  return { summary: String(reply?.summary ?? '').slice(0, 600), overall, recommendation, reasons, scores: out, criteria, look, facts: f };
+}
+
+export const RECOMMENDATION = { ready: 'Ready to approve', look: 'Look at these first', not_ready: 'Not ready' };
+
+/** Markdown: for Copy / Download, the pull request's description and a PR comment. */
+export function scorecardMarkdown(sc, title = '') {
+  const bar = (n) => (n == null ? '—' : `${n}`);
+  const rows = DIMENSIONS.map(([k, label]) => {
+    const d = sc.scores[k];
+    return `| ${label} | ${bar(d?.score)} | ${d ? [d.why, ...d.notes].filter(Boolean).join('; ').replace(/\|/g, '/') : k === 'spec' ? 'no spec written' : '—'} |`;
+  });
+  const out = [
+    `### Review scorecard${title ? `: ${title}` : ''}`,
+    '',
+    `**${sc.overall ?? '—'}/100 · ${RECOMMENDATION[sc.recommendation]}**${sc.reasons.length ? ` (${sc.reasons.join('; ')})` : ''}`,
+    '',
+    sc.summary,
+    '',
+    '| Score | /100 | Why |',
+    '| --- | --- | --- |',
+    ...rows,
+  ];
+  if (sc.criteria.length) {
+    out.push('', '**Acceptance criteria**', '');
+    for (const c of sc.criteria) out.push(`- ${c.status === 'met' ? '✅' : c.status === 'not_met' ? '❌' : '❔'} ${c.criterion}${c.evidence ? ` (${c.evidence})` : ''}`);
+  }
+  if (sc.look.length) {
+    out.push('', '**Where to look**', '');
+    for (const l of sc.look) out.push(`- \`${l.file}\` \`${l.head.replace(/^(@@[^@]*@@).*/, '$1')}\`: ${l.reason}`);
+  }
+  const f = sc.facts;
+  out.push('', `<sub>Measured: ${f.files} files (+${f.added} −${f.removed}), ${f.testFiles} test files, CI ${f.ci ?? 'n/a'}, checks ${f.checks.passed}✓ ${f.checks.failed}✗${f.plan ? `, plan ${f.plan.done}/${f.plan.steps}` : ''}. Scored by AI Agent Manager.</sub>`);
+  return out.join('\n');
+}

package/src/server.js

@@ -241,6 +241,7 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
     }),
   );
   api.get('/agents/:id/specs/:name', wrap((req) => manager.specDoc(req.params.id, req.params.name)));
+  api.post('/agents/:id/scorecard/post', wrap((req) => review.postScorecard(req.params.id)));
   api.post('/agents/:id/plan', wrap((req) => manager.startPlanning(req.params.id)));
   api.post('/agents/:id/plan/approve', wrap((req) => manager.approvePlan(req.params.id, req.body?.note)));
   api.post('/agents/:id/plan/changes', wrap((req) => manager.requestPlanChanges(req.params.id, req.body?.note)));