@arjunkhera/atlas 0.3.21 → 0.3.22

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, for any repository.",
   "author": {
     "name": "Arjun Khera"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arjunkhera/atlas",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "description": "Atlas: the delivery lifecycle, its crews and the Atlas tools, as a Claude Code plugin for any repository.",
   "type": "module",
   "license": "UNLICENSED",

package/skills/sdlc-task/SKILL.md

@@ -38,7 +38,7 @@ checks and the transition log; each verb's own description says what it needs.
 | Ask the owner something, or record the answer | `question_ask`, `question_answer` |
 | Record a decision in the owner's words | `decision_record` |
 | Mark it delivered, or reopen it | `item_done`, `item_reopen` |
-| Say where things stand | `where_are_we`, `in_flight`, `needs_me` |
+| Say where things stand | `roundup` for a whole product; `where_are_we`, `in_flight`, `needs_me` for one question |
 
 The repo's own facts come from `atlas.yaml` and `atlas/`. Its kinds (`service`,
 `library`, `schema`, `cli`, `plugin`) decide which procedures it has and what

package/work/lib/roundup.mjs

@@ -0,0 +1,206 @@
+// The roundup: where one product stands, and where it is going (target design
+// flow 9). Tracker item b1610d9b moved it forward from stage 4 (decision
+// 3c268725).
+//
+// It joins the reads that ship already and adds no store:
+//   1. Needs you        the same read as needs_me
+//   2. Where we stand   items tagged stage-<n>, in ladder order, and a count of
+//                       every item of the product by lifecycle
+//   3. What moved       delivery marks, merged pull requests and new items in
+//                       the window
+//   4. Stuck or drifting active items with no change for STUCK_DAYS, merged
+//                       but not marked, open pull requests that name no item,
+//                       and questions that wait longer than STUCK_DAYS
+//   5. Trend            per week, for TREND_WEEKS weeks: merges, deliveries,
+//                       new items; and the open questions with the oldest age
+// Every row carries a citation: an item id, a question id or a pull request
+// URL. It is computed at read time and never stored.
+import { refuse, isoDate, LIVE_LIFECYCLES } from './verb-fields.mjs';
+import { oneLine, ROW_LINE_MAX } from './questions.mjs';
+import { readPullsByRepo, pullsOfItem, daysBetween, listLine } from './delivery.mjs';
+
+export const ROUNDUP_READ_VERBS = Object.freeze(['roundup']);
+
+// A free tag that places an item on its product's ladder. An item tagged
+// stage-2 is the stage 2 item or one of its parts.
+export const STAGE_TAG = /^stage-(\d{1,2})$/;
+export const STUCK_DAYS = 14;
+export const TREND_WEEKS = 4;
+const DEFAULT_WINDOW = 7;
+const MAX_WINDOW = 90;
+const MAX_ITEMS = 500;
+const MAX_REPOS = 16;
+const SHOWN = 8;
+const DAY = 86_400_000;
+const LIFECYCLE_ORDER = ['active', 'proposed', 'paused', 'done', 'dropped'];
+
+const plural = (count, word) => `${count} ${count === 1 ? word : (/[^aeiou]y$/.test(word) ? `${word.slice(0, -1)}ies` : `${word}s`)}`;
+const dayOf = (value) => String(value ?? '').slice(0, 10);
+const minus = (readAt, days) => new Date(Date.parse(readAt) - days * DAY).toISOString();
+
+export function stageOf(item) {
+  const tags = Array.isArray(item?.tags) ? item.tags : [];
+  const numbers = tags.map((tag) => STAGE_TAG.exec(String(tag).toLowerCase())).filter(Boolean).map((match) => Number(match[1]));
+  return numbers.length ? Math.min(...numbers) : null;
+}
+
+// The ladder: each stage number with its items, lowest stage first. A stage
+// reads "done" only when every item on it is done or dropped.
+export function ladderOf(items) {
+  const byStage = new Map();
+  for (const item of items) {
+    const stage = stageOf(item);
+    if (stage === null) continue;
+    if (!byStage.has(stage)) byStage.set(stage, []);
+    byStage.get(stage).push(item);
+  }
+  return [...byStage.entries()].sort((a, b) => a[0] - b[0]).map(([stage, list]) => {
+    const rows = list.map((item) => ({ item: item.id, title: oneLine(item.title, 120), lifecycle: item.fields?.lifecycle ?? 'unknown', stage: item.fields?.stage ?? '' }))
+      .sort((a, b) => LIFECYCLE_ORDER.indexOf(a.lifecycle) - LIFECYCLE_ORDER.indexOf(b.lifecycle) || a.title.localeCompare(b.title));
+    const counts = countBy(rows.map((row) => row.lifecycle));
+    const live = rows.filter((row) => LIVE_LIFECYCLES.includes(row.lifecycle));
+    const state = !live.length ? 'done' : (rows.some((row) => row.lifecycle === 'active') ? 'doing' : (rows.some((row) => row.lifecycle === 'done') ? 'started' : 'not started'));
+    return { stage, state, counts, rows };
+  });
+}
+
+export function countBy(values) {
+  const counts = {};
+  for (const value of values) counts[value] = (counts[value] ?? 0) + 1;
+  return Object.fromEntries(Object.entries(counts).sort((a, b) => {
+    const rank = (key) => { const at = LIFECYCLE_ORDER.indexOf(key); return at === -1 ? LIFECYCLE_ORDER.length : at; };
+    return rank(a[0]) - rank(b[0]) || a[0].localeCompare(b[0]);
+  }));
+}
+const countLine = (counts) => Object.entries(counts).map(([key, value]) => `${value} ${key}`).join(', ') || 'none';
+
+// The week a moment falls in, counted back from the read: week 1 is the last
+// seven days. A moment outside the trend is null.
+export function weekOf(at, readAt, weeks = TREND_WEEKS) {
+  const age = Date.parse(readAt) - Date.parse(at ?? '');
+  if (Number.isNaN(age) || age < 0) return null;
+  const week = Math.floor(age / (7 * DAY)) + 1;
+  return week > weeks ? null : week;
+}
+
+export function createRoundupVerbs(core) {
+  const { client, now, typeNamed, registry, requireProduct, readGitHub, inFlight, needsMe } = core;
+  return {
+    async roundup(args = {}) {
+      if (args.product === undefined) refuse('product is required: a roundup answers for one product');
+      const reg = await registry();
+      const product = (await requireProduct(args.product, reg)).fields.registry_id;
+      const windowDays = args.days === undefined ? DEFAULT_WINDOW : args.days;
+      if (!Number.isInteger(windowDays) || windowDays < 1 || windowDays > MAX_WINDOW) refuse(`days must be a whole number from 1 to ${MAX_WINDOW}`);
+      const readAt = now();
+      const since = minus(readAt, windowDays);
+      const trendFrom = minus(readAt, Math.max(windowDays, TREND_WEEKS * 7));
+
+      // Parts 1 and 4 reuse the two views that ship, so one rule serves both.
+      const needs = await needsMe({ product });
+      const flight = await inFlight({ product, since: isoDate(dayOf(trendFrom), 'since') });
+
+      const container = await typeNamed('container');
+      const all = await client.listAllEntities({ type: container.name, state: 'active' });
+      const items = all.filter((row) => row.fields?.product === product);
+      if (items.length > MAX_ITEMS) refuse(`${items.length} items belong to ${product}; the roundup reads at most ${MAX_ITEMS}`);
+
+      const repoIds = [...reg.repos.values()].filter((repo) => repo.fields.product === product).map((repo) => repo.fields.registry_id).sort();
+      if (repoIds.length > MAX_REPOS) refuse(`${repoIds.length} repos are registered for ${product}; the roundup reads at most ${MAX_REPOS}`);
+      const { pullsByRepo, repoErrors } = await readPullsByRepo(repoIds, readGitHub);
+
+      // Which item each pull request belongs to: an item that links it or
+      // whose id it names, as in_flight reads it.
+      const owner = new Map();
+      for (const item of items) for (const pull of pullsOfItem(item, pullsByRepo, repoIds)) if (!owner.has(pull.url)) owner.set(pull.url, item.id);
+      const pulls = [...pullsByRepo.values()].flat();
+
+      // 1. Needs you.
+      const needRows = (needs.products?.[0]?.rows ?? []).map((row) => ({
+        question: row.question_id, item: row.item, text: oneLine(row.folded?.question ?? row.lines?.[0] ?? '', 200), item_title: oneLine(row.folded?.item_title ?? '', 120),
+        asked_at: row.asked_at, days_waiting: daysBetween(row.asked_at, readAt), cost: row.cost,
+      }));
+
+      // 2. Where we stand.
+      const ladder = ladderOf(items);
+      const lifecycles = countBy(items.map((row) => row.fields?.lifecycle ?? 'unknown'));
+      const active = (flight.products?.[0]?.rows ?? []).map((row) => ({ item: row.item, title: oneLine(row.folded?.title ?? '', 120), stage: row.stage, days_since_last_change: row.days_since_last_change, waits_on: row.waits_on ?? null }));
+
+      // 3. What moved, in the window.
+      const merged = pulls.filter((pull) => pull.state === 'merged' && String(pull.merged_at) >= since)
+        .map((pull) => ({ pr: pull.url, title: pull.title, merged_at: pull.merged_at, item: owner.get(pull.url) ?? null }))
+        .sort((a, b) => String(b.merged_at).localeCompare(String(a.merged_at)));
+      const deliveries = (flight.delivered ?? []).filter((row) => String(row.delivered_at) >= since)
+        .map((row) => ({ item: row.item, title: row.item_title, verdict: row.verdict, delivered_at: row.delivered_at, prs: row.prs }));
+      const created = items.filter((row) => String(row.created_at ?? '') >= since)
+        .map((row) => ({ item: row.id, title: oneLine(row.title, 120), lifecycle: row.fields?.lifecycle ?? 'unknown', created_at: row.created_at }))
+        .sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
+
+      // 4. Stuck or drifting.
+      const stale = active.filter((row) => row.days_since_last_change !== null && row.days_since_last_change >= STUCK_DAYS);
+      const notMarked = (flight.merged_not_marked ?? []).map((row) => ({ item: row.item, pr: row.pr, title: row.title, days: row.days }));
+      const openNoItem = pulls.filter((pull) => pull.state === 'open' && !owner.has(pull.url)).map((pull) => ({ pr: pull.url, title: pull.title, updated_at: pull.updated_at }));
+      const longWaits = needRows.filter((row) => row.days_waiting !== null && row.days_waiting >= STUCK_DAYS);
+
+      // 5. Trend, per week; week 1 is the last seven days.
+      const weeks = Array.from({ length: TREND_WEEKS }, (_, index) => ({ week: index + 1, from: dayOf(minus(readAt, (index + 1) * 7)), to: dayOf(minus(readAt, index * 7)), merged: 0, delivered: 0, new_items: 0 }));
+      const bump = (at, key) => { const week = weekOf(at, readAt); if (week) weeks[week - 1][key] += 1; };
+      for (const pull of pulls) if (pull.state === 'merged') bump(pull.merged_at, 'merged');
+      for (const row of flight.delivered ?? []) bump(row.delivered_at, 'delivered');
+      for (const row of items) bump(row.created_at, 'new_items');
+      const oldest = needRows.reduce((max, row) => Math.max(max, row.days_waiting ?? 0), 0);
+
+      const text = render({ product, readAt, windowDays, needRows, ladder, lifecycles, active, merged, deliveries, created, stale, notMarked, openNoItem, longWaits, weeks, oldest, repoErrors });
+      return {
+        verb: 'roundup', read_at: readAt, product, window_days: windowDays, since,
+        needs_you: needRows,
+        where_we_stand: { ladder, lifecycles, active },
+        what_moved: { merged, delivered: deliveries, new_items: created },
+        stuck_or_drifting: { stale, merged_not_marked: notMarked, open_prs_with_no_item: openNoItem, long_waits: longWaits, stuck_days: STUCK_DAYS },
+        trend: { weeks, open_questions: needRows.length, oldest_question_days: oldest },
+        repos_read: repoIds, repo_errors: repoErrors,
+        citation: { product, read_at: readAt, items: items.length, repos: repoIds },
+        text,
+      };
+    },
+  };
+}
+
+function render(view) {
+  const { product, readAt, windowDays, needRows, ladder, lifecycles, active, merged, deliveries, created, stale, notMarked, openNoItem, longWaits, weeks, oldest, repoErrors } = view;
+  const more = (list) => (list.length > SHOWN ? [`   and ${list.length - SHOWN} more`] : []);
+  const out = [`${product} — roundup, ${dayOf(readAt)}`];
+
+  out.push([`1. Needs you (${needRows.length})`,
+    ...(needRows.length ? needRows.slice(0, SHOWN).map((row) => listLine(row.text, `${row.question} · asked ${dayOf(row.asked_at)}, ${plural(row.days_waiting ?? 0, 'day')}`)) : ['   nothing']),
+    ...more(needRows)].join('\n'));
+
+  const stand = [`2. Where we stand · items: ${countLine(lifecycles)}`];
+  if (ladder.length) for (const step of ladder) stand.push(`   ${oneLine(`Stage ${step.stage}: ${step.state} · ${countLine(step.counts)} · ${step.rows.filter((row) => LIVE_LIFECYCLES.includes(row.lifecycle)).map((row) => `${row.title} (${row.lifecycle}, ${row.item.slice(0, 8)})`).join('; ') || 'all closed'}`, ROW_LINE_MAX - 3)}`);
+  else stand.push('   no item carries a stage-<n> tag');
+  stand.push(`   in flight (${active.length})`);
+  stand.push(...(active.length ? active.slice(0, SHOWN).map((row) => listLine(row.title, `${row.item} · ${row.stage || 'no stage'} · ${row.days_since_last_change ?? '?'} days since last change`, '     ')) : ['     nothing']));
+  out.push(stand.join('\n'));
+
+  out.push([`3. What moved, last ${plural(windowDays, 'day')}`,
+    `   ${plural(deliveries.length, 'delivery')} · ${plural(merged.length, 'merged pull request')} · ${plural(created.length, 'new item')}`,
+    ...deliveries.slice(0, SHOWN).map((row) => listLine(`delivered: ${row.title}`, `${row.item} · ${dayOf(row.delivered_at)}`)),
+    ...merged.slice(0, SHOWN).map((row) => listLine(`merged: ${row.title}`, `${row.pr} · ${dayOf(row.merged_at)}${row.item ? '' : ' · no item'}`)),
+    ...more(merged),
+    ...created.slice(0, SHOWN).map((row) => listLine(`new: ${row.title}`, `${row.item} · ${row.lifecycle}`)),
+    ...more(created)].join('\n'));
+
+  const stuck = [`4. Stuck or drifting`];
+  stuck.push(`   no change in ${STUCK_DAYS} days or more (${stale.length})`, ...stale.slice(0, SHOWN).map((row) => listLine(row.title, `${row.item} · ${row.days_since_last_change} days`, '     ')));
+  stuck.push(`   merged, not marked (${notMarked.length})`, ...notMarked.slice(0, SHOWN).map((row) => listLine(row.title, `${row.pr} · ${row.item}`, '     ')));
+  stuck.push(`   open pull requests with no item (${openNoItem.length})`, ...openNoItem.slice(0, SHOWN).map((row) => listLine(row.title, row.pr, '     ')));
+  stuck.push(`   questions waiting ${STUCK_DAYS} days or more (${longWaits.length})`, ...longWaits.slice(0, SHOWN).map((row) => listLine(row.text, `${row.question} · ${row.days_waiting} days`, '     ')));
+  out.push(stuck.join('\n'));
+
+  out.push([`5. Trend, per week (week 1 is the last seven days)`,
+    ...weeks.map((week) => `   week ${week.week} (${week.from} to ${week.to}): ${plural(week.merged, 'merge')} · ${plural(week.delivered, 'delivery')} · ${plural(week.new_items, 'new item')}`),
+    `   waiting on you: ${plural(needRows.length, 'question')}${needRows.length ? `, oldest ${plural(oldest, 'day')}` : ''}`].join('\n'));
+
+  if (repoErrors.length) out.push([`GitHub did not answer for ${plural(repoErrors.length, 'repo')}; parts 3 to 5 count from the graph only`, ...repoErrors.map((row) => oneLine(`   ${row.repo} — ${row.reason}`, ROW_LINE_MAX))].join('\n'));
+  return out.join('\n\n');
+}

package/work/lib/verbs.mjs

@@ -20,6 +20,7 @@ import { createQuestionVerbs, COSTS, QUESTION_WRITE_VERBS, QUESTION_READ_VERBS,
 import { createDeliveryVerbs, DELIVERY_WRITE_VERBS, DELIVERY_READ_VERBS } from './delivery.mjs';
 import { createCapabilityVerbs, CAPABILITY_READ_VERBS, hubOf } from './capability.mjs';
 import { createSweepVerbs, SWEEP_WRITE_VERBS, SWEEP_READ_VERBS } from './sweep.mjs';
+import { createRoundupVerbs, ROUNDUP_READ_VERBS } from './roundup.mjs';
 import { createActivityVerbs, diffOf, LOG_VERBS, ENTRY_VERBS, ACTIVITY_WRITE_VERBS, ACTIVITY_READ_VERBS } from './activity.mjs';
 
 export { VerbError, canonicalJson, sha256, COSTS, LIVE_LIFECYCLES, REPO_KINDS, LIVE_KINDS, repoKinds };
@@ -751,11 +752,12 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
   Object.assign(verbs, createDeliveryVerbs({ ...core, ownerPresent, readGitHub, readLive }));
   Object.assign(verbs, createCapabilityVerbs({ ...core, readGitHub }));
   Object.assign(verbs, createSweepVerbs({ ...core, requireRepos, inFlight: (args) => verbs.in_flight(args), stages: STAGES, tiers: TIERS, drivers: DRIVERS }));
+  Object.assign(verbs, createRoundupVerbs({ ...core, readGitHub, inFlight: (args) => verbs.in_flight(args), needsMe: (args) => verbs.needs_me(args) }));
   const activity = createActivityVerbs(core);
   Object.assign(verbs, activity.verbs);
 
   const WRITE_VERBS = Object.freeze(['setup', 'product_add', 'product_edit', 'repo_add', 'repo_edit', 'item_propose', 'item_lock', 'item_split', 'item_park', 'item_resume', 'item_drop', 'item_edit', 'item_block', 'item_unblock', 'item_stage', 'item_link', ...QUESTION_WRITE_VERBS, ...DELIVERY_WRITE_VERBS, ...SWEEP_WRITE_VERBS, ...ACTIVITY_WRITE_VERBS]);
-  const READ_VERBS = Object.freeze(['registry_list', ...QUESTION_READ_VERBS, ...DELIVERY_READ_VERBS, ...CAPABILITY_READ_VERBS, ...SWEEP_READ_VERBS, ...ACTIVITY_READ_VERBS]);
+  const READ_VERBS = Object.freeze(['registry_list', ...QUESTION_READ_VERBS, ...DELIVERY_READ_VERBS, ...CAPABILITY_READ_VERBS, ...SWEEP_READ_VERBS, ...ROUNDUP_READ_VERBS, ...ACTIVITY_READ_VERBS]);
 
   async function run(verb, args = {}) {
     if (!verbs[verb]) refuse(`unknown verb: ${verb}`);

package/work/mcp.mjs

@@ -69,6 +69,7 @@ export const TOOLS = [
   { name: 'in_flight', description: 'Answer "what are we working on, and what changed since a date?". Active items per product, ordered by the owner\'s current priority decision first, when it carries an order, then by days since the last change with the latest on top, and the days shown on each row. Each row says what the item waits on. Movement is read from the marks and from each registered repo\'s recent pull requests: the item\'s own pr links, plus any pull request whose title, body or branch names the item id. Merged pull requests with no delivery mark are listed as "merged, not marked". A legacy seal reads as a delivery mark with verdict "legacy". Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', properties: { product: S('Limit the view to one product id.'), since: S('ISO date. Adds what was delivered since then.') }, additionalProperties: false } },
   { name: 'sweep_check', description: 'Check the sweep against the "In flight" view: the newest decision record of kind sweep names the items the owner called in flight, and this reads the view and names every difference — what is listed and not in flight, and what is in flight and not listed. A product with no sweep on record is named too. It answers two things apart: `matches` says each product\'s view holds exactly what its sweep lists, and `complete` says that and that no item in the tenant sits outside every product. An item nobody adopted is missing from both sides, so `matches` alone can read "equal" over an unfinished sweep. Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', properties: { product: S('Limit the check to one product id.') }, additionalProperties: false } },
   { name: 'needs_me', description: 'Answer "what needs me?": every open question on a proposed, active or paused item, per product, ordered by what waiting costs. A row on an item that is not active names its lifecycle. Each row is three lines, the question, the item and the cost, with the context folded under it. Computed at read time and never stored. Scope: read, no owner flag needed. Pass the row text back as rendered when the owner answers.', inputSchema: { type: 'object', properties: { product: S('Limit the view to one product id.') }, additionalProperties: false } },
+  { name: 'roundup', description: 'Answer "where does this product stand, and where is it going?" in five parts: 1 needs you (the needs_me read); 2 where we stand (items tagged stage-<n> in ladder order, a count of every item by lifecycle, and the active items); 3 what moved in the window (delivery marks, merged pull requests, new items); 4 stuck or drifting (active items with no change for 14 days, merged but not marked, open pull requests that name no item, questions waiting 14 days); 5 the trend per week for four weeks. Every row cites an item, a question or a pull request. Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', required: ['product'], properties: { product: S('Product id.'), days: { type: 'integer', minimum: 1, maximum: 90, description: 'The window for part 3, in days. Default 7.' } }, additionalProperties: false } },
   { name: 'code_read_brief', description: 'The brief for the sub-agents that read the code for "where are we with X", one per registered repo of the product. It carries the never-read and never-quote rules, the citation contract and the JSON shape of the digest. Give one brief to one sub-agent; sub-agents never receive this server or the Engram MCP. Pass each digest back in where_are_we.code. When: before answering "where are we with X". Scope: read, no owner flag needed; it opens no repo and writes nothing.', inputSchema: { type: 'object', required: ['product', 'capability'], properties: { product: S('Product registry id.'), capability: S('The capability to read for, the X of the question.'), repos: { type: 'array', description: 'Limit the briefs to these registered repo ids. Default: every repo of the product.', items: { type: 'string' } }, roots: { type: 'object', description: 'Repo id to the local checkout path the sub-agent reads.', additionalProperties: { type: 'string' } }, commits: { type: 'object', description: 'Repo id to the commit the read runs against.', additionalProperties: { type: 'string' } }, focus: { type: 'array', description: 'Extra things the read should look for.', items: { type: 'string' } } }, additionalProperties: false } },
   { name: 'where_are_we', description: 'Answer "where are we with X" in six parts: live support and known limits from the code read at question time, then in progress, delivered and proposed from the items, then the current priority decision. Every row carries a citation: a path and a line, an entity id, a pull request, or a decision date. The code half comes from the sub-agent digests, which are refused when they cite a never-read path or quote a never-quote path, and every string is scrubbed by pattern. Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', required: ['product', 'capability', 'code'], properties: { product: S('Product registry id.'), capability: S('The capability the question is about, the X.'), code: { type: 'array', description: 'One digest per repo, from the sub-agents briefed by code_read_brief. At least one is required: an answer with no code read says nothing about what the code does today.', items: CODE_DIGEST }, items: { type: 'array', description: 'Item ids the lead judges to answer this question.', items: { type: 'string' } }, match: { type: 'array', description: 'Terms to match against item titles, summaries and tags. Give items, match, or both.', items: { type: 'string' } }, movement_repos: { type: 'array', description: "Narrow the movement read to these registered repo ids. Default: every repo of the product. The digests' own repos are always read.", items: { type: 'string' } }, since: S('ISO date. Adds what changed since then.') }, additionalProperties: false } },
   { name: 'built_pending_possible', description: 'Answer "what are we building, what is built, what is pending and what can be done": delivered items by date, active items, paused items with their reason, proposed items with their age, and the decisions that set the order. Item records, delivery marks and decisions only; no code read and no GitHub read. Computed at read time and never stored. Scope: read, no owner flag needed.', inputSchema: { type: 'object', properties: { product: S('Limit the view to one product id.'), since: S('ISO date. Limits built and the decisions to what came after it.') }, additionalProperties: false } },