@arjunkhera/atlas 0.3.10 → 0.3.12

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "atlas",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "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.10",
+  "version": "0.3.12",
   "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

@@ -33,6 +33,8 @@ checks and the transition log; each verb's own description says what it needs.
 | Drop it, in the owner's words (`item_resume` undoes a drop) | `item_drop` |
 | Keep its next step, its wait or its title true | `item_edit` |
 | Split it, or link it to other work | `item_split`, `item_link` |
+| Mark that it waits on another item, or clear that | `item_block`, `item_unblock` |
+| Keep a note on it, or read what happened on it | `item_comment`, `item_activity` |
 | 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` |

package/work/lib/activity.mjs

@@ -0,0 +1,246 @@
+// Work item additions, slice 3: the log of a work item.
+// The design: the work item additions, steps 5, 6, 8 and 9.
+//
+// One record type, entry, holds both a comment and a change. Each entry
+// carries the tag item:<id>, so one list by type and tag finds every entry of
+// an item: no scan of the tenant and no edge walk.
+//
+// The item verbs put a short diff into their own receipt on the item, in the
+// same write (verbs.mjs, patch). After the verb, logEntries copies the diff
+// into an entry. That second write is best effort: a failure is a warning,
+// the diff stays in the receipt, and the next write on the item tries again.
+import { VerbError, refuse, text, oneOf, LIVE_LIFECYCLES } from './verb-fields.mjs';
+import { oneLine, scrubSecrets } from './questions.mjs';
+
+export const ACTIVITY_WRITE_VERBS = Object.freeze(['item_comment']);
+export const ACTIVITY_READ_VERBS = Object.freeze(['item_activity']);
+export const VOICES = Object.freeze(['agent', 'owner']);
+// The item verbs whose writes carry a diff (step 9). item_propose writes a
+// "created" diff when it makes the item.
+export const LOG_VERBS = Object.freeze(['item_lock', 'item_split', 'item_park', 'item_resume', 'item_drop', 'item_edit', 'item_stage', 'item_link', 'item_block', 'item_unblock', 'item_done', 'item_reopen', 'item_adopt']);
+export const ENTRY_VERBS = Object.freeze(['item_propose', ...LOG_VERBS]);
+const MAX_COMMENT = 4000;
+const PREVIEW = 300;
+// How many missing entries one write repairs, beside its own. Only a diff
+// older than REPAIR_AFTER is repaired, so a write running at the same moment
+// on the same item copies its own diff and no other writer copies it too.
+const MAX_REPAIR = 4;
+const REPAIR_AFTER_MS = 120_000;
+const MAX_LIST_ITEMS = 20;
+// Bookkeeping fields and stamps: the entry has its own time, so these are
+// left out of the diff.
+const NOT_LOGGED = new Set(['writer', 'request_id', 'atlas_receipts', 'edits', 'first_title', 'stage_changed_at', 'parked_at', 'resumed_at', 'undropped_at', 'dropped_at']);
+export const itemTag = (id) => `item:${id}`;
+
+// One value as the log keeps it. A text, number, true, false or null up to
+// 300 characters stays whole. A longer text, a list or an object becomes a
+// 300-character preview with cut. The secret filter runs on every value.
+function shown(value) {
+  if (value === undefined) return { value: null, cut: false };
+  if (value === null || typeof value === 'number' || typeof value === 'boolean') return { value, cut: false };
+  const whole = typeof value === 'string' ? value : JSON.stringify(value);
+  // Cut by code point: half an emoji makes Postgres refuse the whole write.
+  const chars = Array.from(scrubSecrets(whole).text);
+  if (typeof value === 'string' && chars.length <= PREVIEW) return { value: chars.join(''), cut: false };
+  return { value: chars.length <= PREVIEW ? chars.join('') : `${chars.slice(0, PREVIEW - 1).join('')}…`, cut: true };
+}
+const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+const isList = (value) => Array.isArray(value) || value === undefined || value === null;
+// A list is kept as the members it gained and lost, each shown on its own,
+// so a member at the end of a long list is never cut away.
+function pair(from, to) {
+  if (isList(from) && isList(to) && (Array.isArray(from) || Array.isArray(to))) {
+    const before = from ?? [], after = to ?? [];
+    const gone = before.filter((row) => !after.some((other) => same(row, other)));
+    const come = after.filter((row) => !before.some((other) => same(row, other)));
+    const list = (rows) => rows.slice(0, MAX_LIST_ITEMS).map((row) => shown(row));
+    const added = list(come), removed = list(gone);
+    const cut = come.length > MAX_LIST_ITEMS || gone.length > MAX_LIST_ITEMS || [...added, ...removed].some((row) => row.cut);
+    return { added: added.map((row) => row.value), removed: removed.map((row) => row.value), ...(cut ? { cut: true } : {}) };
+  }
+  const a = shown(from), b = shown(to);
+  return { from: a.value, to: b.value, ...(a.cut || b.cut ? { cut: true } : {}) };
+}
+
+// The diff of one write: each field it changes, as from and to. The title
+// and the tags count as fields.
+export function diffOf(current, next, { title, tags } = {}) {
+  const change = {};
+  for (const [key, value] of Object.entries(next ?? {})) {
+    if (NOT_LOGGED.has(key)) continue;
+    if (!same(current?.fields?.[key], value)) change[key] = pair(current?.fields?.[key], value);
+  }
+  if (title !== undefined && title !== current?.title) change.title = pair(current?.title ?? null, title);
+  if (tags !== undefined && !same(current?.tags ?? [], tags)) change.tags = pair(current?.tags ?? [], tags);
+  return change;
+}
+
+export function createActivityVerbs(core) {
+  const { client, label, now, typeNamed, requireItem, requireOwner, create, alreadyPatched } = core;
+
+  // The entry type, or null before the owner has run setup for 0.7.0.
+  async function entryType() {
+    try { return await typeNamed('entry'); }
+    catch (error) { if (error instanceof VerbError) return null; throw error; }
+  }
+  async function entriesOf(type, itemId) {
+    const rows = await client.listAllEntities({ type: type.name, tag: itemTag(itemId) });
+    return rows.filter((row) => row.fields?.item === itemId);
+  }
+  // The newest entries of an item, one page. An item holds at most 100
+  // receipts, so only its newest entries can match one.
+  async function recentEntries(type, itemId) {
+    if (typeof client.listEntities !== 'function') return entriesOf(type, itemId);
+    const page = await client.listEntities({ type: type.name, tag: itemTag(itemId), order: 'created_at_desc', limit: 200 });
+    return (Array.isArray(page?.entities) ? page.entities : []).filter((row) => row.fields?.item === itemId);
+  }
+  const changeIds = (rows) => new Set(rows.filter((row) => row.fields?.kind === 'change').map((row) => row.fields.request_id));
+  // The request ids that already have a change entry on this item. A failed
+  // read never stops the item write: the trim then goes by size only.
+  async function loggedIds(itemId) {
+    try {
+      const type = await entryType();
+      return type ? changeIds(await recentEntries(type, itemId)) : new Set();
+    } catch { return new Set(); }
+  }
+
+  // Copy the diff of this request into an entry, and repair a few older ones
+  // that never landed. Returns a warning, or null. It never throws: the item
+  // write already landed, so the verb succeeds.
+  async function logEntries(itemId, requestId) {
+    const keep = 'The values stay in the item\'s receipt, and the next write on the item tries again.';
+    try {
+      const type = await entryType();
+      if (!type) return `no log entry was written: the entry type is not registered, so the owner runs setup for manifest 0.7.0. ${keep}`;
+      const item = await client.getEntity(itemId);
+      const receipts = item.fields?.atlas_receipts ?? {};
+      if (!receipts[requestId]?.change) return null;
+      const have = changeIds(await recentEntries(type, item.id));
+      const cutoff = Date.parse(now()) - REPAIR_AFTER_MS;
+      const older = Object.entries(receipts).filter(([id, receipt]) => id !== requestId && receipt?.change && !have.has(id) && Date.parse(receipt.at) < cutoff)
+        .sort(([, a], [, b]) => String(b.at ?? '').localeCompare(String(a.at ?? ''))).slice(0, MAX_REPAIR);
+      const pending = [...(have.has(requestId) ? [] : [[requestId, receipts[requestId]]]), ...older];
+      for (const [id, receipt] of pending) {
+        await create(type, id, receipt.verb, {
+          title: oneLine(`${receipt.verb} · ${item.title ?? item.id}`, 200),
+          fields: { item: item.id, ...(item.fields?.product ? { product: item.fields.product } : {}), kind: 'change', verb: receipt.verb, change: receipt.change, ...(receipt.note ? { text: receipt.note } : {}), at: receipt.at },
+          tags: [itemTag(item.id), ...(item.fields?.product ? [`product:${item.fields.product}`] : [])],
+          readBack: false,
+        });
+      }
+      return null;
+    } catch (error) {
+      return `the log entry was not written: ${error?.message ?? String(error)}. ${keep}`;
+    }
+  }
+
+  const verbs = {
+    // A comment on an item, from the lead or in the owner's words.
+    async item_comment(args, requestId, meta) {
+      const item = await requireItem(args.item_id);
+      const voice = oneOf(args.voice, 'voice', VOICES, 'agent');
+      if (voice === 'owner') requireOwner('item comment in the owner\'s voice');
+      const words = text(args.text, 'text', { max: MAX_COMMENT });
+      const type = await typeNamed('entry');
+      const entries = await entriesOf(type, item.id);
+      const prior = entries.find((row) => row.fields?.request_id === requestId);
+      if (prior && alreadyPatched(prior, requestId, meta)) return { verb: 'item_comment', item_id: item.id, entry_id: prior.id, voice: prior.fields.voice, redactions: prior.fields.redactions ?? 0, ...(prior.fields.corrects ? { corrects: prior.fields.corrects } : {}), replayed_from_graph: true };
+      if (!LIVE_LIFECYCLES.includes(item.fields?.lifecycle)) refuse(`item ${item.id} is ${item.fields?.lifecycle}; only a proposed, active or paused item takes a comment`);
+      let corrects;
+      if (args.corrects !== undefined) {
+        text(args.corrects, 'corrects', { max: 200 });
+        const old = entries.find((row) => row.id === args.corrects && row.fields?.kind === 'comment');
+        if (!old) refuse(`corrects must name a comment on item ${item.id}`);
+        corrects = old.id;
+      }
+      const clean = scrubSecrets(words);
+      const entity = await create(type, requestId, 'item_comment', {
+        digest: meta?.digest, title: oneLine(`comment · ${item.title ?? item.id}`, 200), body: clean.text,
+        fields: { item: item.id, ...(item.fields?.product ? { product: item.fields.product } : {}), kind: 'comment', voice, text: clean.text, ...(corrects ? { corrects } : {}), redactions: clean.redactions, at: now() },
+        tags: [itemTag(item.id), ...(item.fields?.product ? [`product:${item.fields.product}`] : [])],
+      });
+      return { verb: 'item_comment', item_id: item.id, entry_id: entity.id, voice, redactions: clean.redactions, ...(corrects ? { corrects } : {}) };
+    },
+
+    // The feed of one item, newest first: its entries, the receipts that have
+    // no entry yet, and its questions, decisions, delivery marks, pieces and
+    // links.
+    async item_activity(args) {
+      const item = await requireItem(args.item_id);
+      const limit = args.limit === undefined ? 50 : Number(args.limit);
+      if (!Number.isInteger(limit) || limit < 1 || limit > 200) refuse('limit must be a whole number from 1 to 200');
+      const fields = item.fields ?? {};
+      const rows = [];
+      const type = await entryType();
+      const entries = type ? await entriesOf(type, item.id) : [];
+      const logged = new Set();
+      for (const row of entries) {
+        const f = row.fields ?? {};
+        if (f.kind === 'comment') rows.push({ at: f.at, kind: 'comment', entry_id: row.id, voice: f.voice, text: f.text, ...(f.corrects ? { corrects: f.corrects } : {}) });
+        else if (f.kind === 'change') {
+          // Two writers can copy the same diff; the feed shows it once.
+          if (logged.has(f.request_id)) continue;
+          logged.add(f.request_id);
+          rows.push({ at: f.at, kind: 'change', entry_id: row.id, verb: f.verb, change: f.change ?? {}, ...(f.text ? { note: f.text } : {}), values_kept: true });
+        } else rows.push({ at: f.at, kind: 'entry', entry_id: row.id, entry_kind: String(f.kind ?? '') });
+      }
+      for (const [id, receipt] of Object.entries(fields.atlas_receipts ?? {})) {
+        if (logged.has(id) || !receipt?.verb) continue;
+        rows.push(receipt.change
+          ? { at: receipt.at, kind: 'change', verb: receipt.verb, change: receipt.change, ...(receipt.note ? { note: receipt.note } : {}), values_kept: true, from_receipt: true }
+          : { at: receipt.at, kind: 'change', verb: receipt.verb, values_kept: false });
+      }
+      // The history kept on the item before slice 3 stays readable.
+      for (const edit of Array.isArray(fields.edits) ? fields.edits : []) rows.push({ at: edit.at, kind: 'edit', previous: edit.previous ?? {}, ...(edit.reason ? { note: edit.reason } : {}) });
+      const optional = async (name) => { try { return await typeNamed(name); } catch (error) { if (error instanceof VerbError) return null; throw error; } };
+      const listOf = async (name) => { const t = await optional(name); return t ? client.listAllEntities({ type: t.name }) : []; };
+      for (const row of await listOf('question')) {
+        if (row.fields?.item !== item.id) continue;
+        rows.push({ at: row.fields.asked_at, kind: 'question', question_id: row.id, status: row.fields.status, text: oneLine(row.fields.text ?? '', PREVIEW) });
+      }
+      for (const row of await listOf('decision')) {
+        if (!Array.isArray(row.fields?.items) || !row.fields.items.includes(item.id)) continue;
+        // A decision holds a day only; the record's own time places it.
+        rows.push({ at: row.created_at ?? row.fields.date, kind: 'decision', decision_id: row.id, decision_kind: row.fields.kind, text: oneLine(row.fields.text ?? '', PREVIEW) });
+      }
+      for (const row of await listOf('mark')) {
+        if (row.fields?.item !== item.id) continue;
+        rows.push({ at: row.fields.marked_at, kind: 'mark', mark_id: row.id, mark_kind: row.fields.kind, verdict: row.fields.verdict ?? null });
+      }
+      const pieces = await Promise.all((Array.isArray(fields.split_children) ? fields.split_children : []).map((id) => client.getEntity(id).catch(() => null)));
+      for (const piece of pieces) {
+        if (!piece) continue;
+        // The piece's date is the split that made it, not its last write.
+        const made = Object.values(piece.fields?.atlas_receipts ?? {}).filter((receipt) => receipt?.verb === 'item_split').map((receipt) => receipt.at).sort()[0] ?? piece.created_at ?? null;
+        rows.push({ at: made, kind: 'piece', item: piece.id, title: oneLine(piece.title ?? '', 200), split_order: piece.fields?.split_order ?? null });
+      }
+      for (const link of Array.isArray(fields.links) ? fields.links : []) rows.push({ at: link.added_at, kind: 'link', link_kind: link.kind, url: link.url, ...(link.role ? { role: link.role } : {}) });
+      rows.sort((a, b) => String(b.at ?? '').localeCompare(String(a.at ?? '')));
+      const shownRows = rows.slice(0, limit);
+      return { verb: 'item_activity', item_id: item.id, title: item.title, total: rows.length, rows: shownRows, lines: shownRows.map(lineOf),
+        ...(type ? {} : { note: 'the entry type is not registered yet; the owner runs setup for manifest 0.7.0. The feed reads the receipts on the item.' }) };
+    },
+  };
+  return { verbs, logEntries, loggedIds };
+}
+
+// One row as one line, for the lead to show.
+function lineOf(row) {
+  const when = String(row.at ?? '').replace('T', ' ').slice(0, 16) || 'no date';
+  const one = (value) => (value === null || value === undefined ? '—' : typeof value === 'string' ? value : JSON.stringify(value));
+  const values = (change) => Object.entries(change ?? {}).map(([key, value]) => (Array.isArray(value?.added)
+    ? `${key}: ${[...value.added.map((row) => `+${one(row)}`), ...value.removed.map((row) => `−${one(row)}`)].join(', ')}`
+    : `${key}: ${one(value?.from)} → ${one(value?.to)}`)).join('; ');
+  switch (row.kind) {
+    case 'comment': return oneLine(`${when}  comment (${row.voice})  "${row.text}"`);
+    case 'change': return oneLine(row.values_kept ? `${when}  ${row.verb}  ${values(row.change) || 'no field changed'}` : `${when}  ${row.verb}  no values recorded`);
+    case 'edit': return oneLine(`${when}  edit  was ${Object.entries(row.previous ?? {}).map(([key, value]) => `${key}: ${one(value)}`).join('; ')}${row.note ? ` · ${row.note}` : ''}`);
+    case 'entry': return oneLine(`${when}  entry of kind ${row.entry_kind}`);
+    case 'question': return oneLine(`${when}  question (${row.status})  ${row.text}`);
+    case 'decision': return oneLine(`${when}  decision (${row.decision_kind})  "${row.text}"`);
+    case 'mark': return oneLine(`${when}  mark  ${row.mark_kind}${row.verdict ? `: ${row.verdict}` : ''}`);
+    case 'piece': return oneLine(`${when}  piece  ${row.title} · ${row.item}`);
+    case 'link': return oneLine(`${when}  link (${row.link_kind})  ${row.url}`);
+    default: return oneLine(`${when}  ${row.kind}`);
+  }
+}

package/work/lib/capability.mjs

@@ -15,7 +15,7 @@
 //      scrubs by pattern. The rendered answer is scrubbed once more before it
 //      leaves the door (R12).
 import { refuse, text, isoDate, stringList } from './verb-fields.mjs';
-import { oneLine, scrubSecrets, ROW_LINE_MAX, priorityOrderOf, byPriority, orderNote, waitsOnLine } from './questions.mjs';
+import { oneLine, scrubSecrets, ROW_LINE_MAX, priorityOrderOf, byPriority, orderNote, waitsOnLine, blockersOf, blocksOf, blockedPhrase, waitsShown } from './questions.mjs';
 import { listLine, legacySealOf, marksByItem, movementOf, pullsOfItem, readPullsByRepo, correctionsOf, daysBetween } from './delivery.mjs';
 import { acceptCodeRead, codeReadBrief } from './code-read.mjs';
 
@@ -391,6 +391,9 @@ export function createCapabilityVerbs(core) {
       const unregisteredTotal = rows.filter(unsorted).length;
       const unregisteredShown = items.filter(unsorted).length;
       const marks = await marksFor(new Set(items.map((row) => row.id)));
+      // Blocked-by links read from every item loaded, so a blocker of another
+      // product still names its state (work item additions, slice 2).
+      const itemById = new Map(rows.map((row) => [row.id, row]));
       const readAt = now();
       let redactions = 0;
       const clean = (value, max = 200) => { const out = scrubSecrets(oneLine(value, max)); redactions += out.redactions; return out.text; };
@@ -437,7 +440,10 @@ export function createCapabilityVerbs(core) {
         }
         const doneAt = fields.delivered_at ?? item.updated_at ?? item.created_at ?? null;
         if (fields.lifecycle === 'done' && !deliveries.length && !(since && String(doneAt ?? '') < since)) built.push({ ...base, mark_id: null, verdict: 'done, no delivery mark', delivered_at: doneAt, prs: [], source: 'no mark yet', note: 'the item record says done; the done verb writes the mark' });
-        const waits = fields.waits_on && typeof fields.waits_on === 'object' ? { waits_on: fields.waits_on } : {};
+        const shown = waitsShown(fields);
+        const blockers = blockersOf(item, (id) => itemById.get(id));
+        const blocks = blocksOf(item, rows);
+        const waits = { ...(shown && typeof shown === 'object' ? { waits_on: shown } : {}), ...(blockers.length ? { blocked_by: blockers } : {}), ...(blocks.length ? { blocks } : {}) };
         if (fields.lifecycle === 'active') building.push({ ...base, ...waits, stage: clean(fields.stage ?? '', 64), driver: clean(fields.driver ?? '', 64), next_step: clean(fields.next_step ?? '', 200), days_since_last_change: days, last_change_source: clean(last?.source ?? 'nothing recorded', 120), delivery_state: fields.delivery_state ? clean(fields.delivery_state, 64) : null });
         else if (fields.lifecycle === 'paused') pending.push({ ...base, ...waits, reason: clean(fields.pause_reason ?? 'no reason on record', 300), days_since_last_change: days, parked_at: fields.parked_at ?? null });
         else if (fields.lifecycle === 'proposed') {
@@ -467,7 +473,7 @@ export function createCapabilityVerbs(core) {
       building.sort(byPriority(orders, byDays));
       pending.sort(byPriority(orders, byDays));
       possible.sort(byPriority(orders, (a, b) => (b.age_days ?? 0) - (a.age_days ?? 0)));
-      const waitsOf = (row) => (row.waits_on ? ` · ${waitsOnLine(row.waits_on)}` : '');
+      const waitsOf = (row) => `${row.waits_on ? ` · ${waitsOnLine(row.waits_on)}` : ''}${blockedPhrase(row.blocked_by ?? [], row.blocks ?? []) ? ` · ${blockedPhrase(row.blocked_by ?? [], row.blocks ?? [])}` : ''}`;
 
       // D3 rule 2: a row names its product. The board does not group, so every
       // line carries the id (review H6).

package/work/lib/delivery.mjs

@@ -13,7 +13,7 @@
 //   3. Movement is read, never stored. The view computes it at question time
 //      from the marks and from the repos' pull requests (D3 rule 5, R1).
 import { refuse, text, isoDate, url, stringList, sha256, repoKinds, LIVE_KINDS } from './verb-fields.mjs';
-import { oneLine, ROW_LINE_MAX, priorityOrderOf, byPriority, orderNote, waitsOnLine } from './questions.mjs';
+import { oneLine, ROW_LINE_MAX, priorityOrderOf, byPriority, orderNote, waitsOnLine, blockersOf, blocksOf, blockedPhrase, waitsShown } from './questions.mjs';
 
 export const DELIVERY_WRITE_VERBS = Object.freeze(['item_done', 'item_reopen']);
 export const DELIVERY_READ_VERBS = Object.freeze(['in_flight']);
@@ -544,6 +544,9 @@ export function createDeliveryVerbs(core) {
       if (items.length > MAX_ITEMS) refuse(`${items.length} items are registered; the view reads at most ${MAX_ITEMS}. Narrow it with a product id.`);
       const byId = new Map(items.map((row) => [row.id, row]));
       const marks = await marksOf(new Set(byId.keys()));
+      // Blocked-by links are read from every item the view loaded, in any
+      // lifecycle, so "blocks" and "cleared" need no extra call.
+      const anyById = new Map(all.map((row) => [row.id, row]));
 
       // Movement from git: every registered repo of the products in view, its
       // recent pull requests, once per repo and shared by every item.
@@ -587,6 +590,10 @@ export function createDeliveryVerbs(core) {
         // D3 rule 1: in flight is active work. Delivered and paused items leave
         // the rows; what was delivered since a date has its own list.
         if (fields.lifecycle !== 'active') continue;
+        const blockers = blockersOf(item, (id) => anyById.get(id));
+        const blocks = blocksOf(item, all);
+        const blocked = blockedPhrase(blockers, blocks);
+        const waits = waitsShown(fields);
         rows.push({
           item: item.id, product: fields.product, stage: fields.stage ?? '', driver: fields.driver ?? '', days_since_last_change: days,
           last_change_at: last?.at ?? null, last_change_source: last?.source ?? 'nothing recorded', delivery_state: state,
@@ -594,10 +601,13 @@ export function createDeliveryVerbs(core) {
             // The id is what a reader types back, so the title gives way to it
             // inside the line budget, as the "Needs me" row does (review G6).
             oneLine(`${oneLine(item.title, Math.max(1, ROW_LINE_MAX - item.id.length - 3))} · ${item.id}`),
-            oneLine(`${fields.product} · ${fields.stage ?? 'no stage'} · ${fields.driver ?? 'no driver'}${waitsOnLine(fields.waits_on) ? ` · ${waitsOnLine(fields.waits_on)}` : ''} · next: ${fields.next_step || 'not set'}`),
+            oneLine(`${fields.product} · ${fields.stage ?? 'no stage'} · ${fields.driver ?? 'no driver'}${waitsOnLine(waits) ? ` · ${waitsOnLine(waits)}` : ''} · next: ${fields.next_step || 'not set'}`),
             oneLine(`${days === null ? 'no movement on record' : `${days} day${days === 1 ? '' : 's'} since last change`} (${last?.source ?? 'nothing recorded'}) · ${mine.length} pull request${mine.length === 1 ? '' : 's'}${open.length ? ` · ${open.length} merged, not marked` : ''}${orderNote(orders, { product: fields.product, item: item.id })}`),
+            // The blockers get their own line, so a long list never cuts the
+            // next step off line two; they come last.
+            ...(blocked ? [oneLine(blocked)] : []),
           ],
-          waits_on: fields.waits_on ?? null,
+          waits_on: waits, blocked_by: blockers, blocks,
           folded: { title: item.title, next_step: fields.next_step ?? '', scope: fields.scope?.text ?? '', pieces: fields.split_children ?? [], prs: mine.map((pull) => ({ url: pull.url, state: pull.state, matched_by: pull.matched_by, merged_at: pull.merged_at, updated_at: pull.updated_at })), marks: own.map((mark) => ({ id: mark.id, kind: mark.fields.kind, verdict: mark.fields.verdict, at: mark.fields.marked_at })) },
           citation: { item: item.id, read_at: readAt, repos: [...new Set(mine.map((pull) => pull.repo))] },
         });

package/work/lib/questions.mjs

@@ -30,7 +30,10 @@ const MAX_RENDERED = 20_000;
 
 export const oneLine = (value, max = ROW_LINE_MAX) => {
   const flat = String(value ?? '').replace(/\s+/g, ' ').trim();
-  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+  // Cut by code point, so a cut never leaves half an emoji: Postgres refuses
+  // a lone surrogate, and the whole write with it.
+  const chars = Array.from(flat);
+  return chars.length > max ? `${chars.slice(0, max - 1).join('')}…` : flat;
 };
 
 // R12: a scrub by pattern in receipt keep. The patterns are the ones the
@@ -98,6 +101,42 @@ export function waitsOnLine(waits) {
   return `waits on ${what}${waits.item ? ` ${waits.item}` : ''}${waits.note ? `: ${waits.note}` : ''}`;
 }
 
+// Work item additions, slice 2: the items that block an item, the items it
+// blocks, and one phrase for a row. lookup gives an item record by id, or
+// undefined when the view did not load it. A blocker that is delivered or
+// dropped no longer blocks; the row shows it as cleared.
+export const CLEARED_LIFECYCLES = Object.freeze(['done', 'dropped']);
+export function blockersOf(item, lookup) {
+  const list = Array.isArray(item?.fields?.blocked_by) ? item.fields.blocked_by : [];
+  return list.filter((entry) => entry && typeof entry.item === 'string').map((entry) => {
+    const other = lookup(entry.item);
+    // A blocker the view cannot find is archived or gone, so it blocks no more.
+    if (!other) return { item: entry.item, title: null, state: 'gone', cleared: true, ...(entry.note ? { note: entry.note } : {}) };
+    const lifecycle = other.fields?.lifecycle ?? 'unknown';
+    const cleared = CLEARED_LIFECYCLES.includes(lifecycle);
+    return { item: entry.item, title: oneLine(other.title, 60), state: cleared ? 'cleared' : (lifecycle === 'active' ? (other.fields?.stage ?? 'active') : lifecycle), cleared, ...(entry.note ? { note: entry.note } : {}) };
+  });
+}
+// Only a live item is still held up, so a delivered or dropped one leaves the
+// "blocks" list.
+export function blocksOf(item, all) {
+  return all.filter((other) => other.id !== item.id && LIVE_LIFECYCLES.includes(other.fields?.lifecycle) && Array.isArray(other.fields?.blocked_by) && other.fields.blocked_by.some((entry) => entry?.item === item.id))
+    .map((other) => ({ item: other.id, title: oneLine(other.title, 60) }));
+}
+export function blockedPhrase(blockers, blocks) {
+  const parts = [];
+  if (blockers.length) parts.push(`blocked by: ${blockers.map((row) => `${row.title ?? row.item} (${row.state})`).join(', ')}`);
+  if (blocks.length) parts.push(`blocks: ${blocks.map((row) => row.title ?? row.item).join(', ')}`);
+  return parts.join(' · ');
+}
+// An old waits_on pointer to an item is hidden when a blocked_by link names
+// the same item, so a row does not say it twice.
+export function waitsShown(fields) {
+  const waits = fields?.waits_on;
+  if (waits?.on === 'item' && Array.isArray(fields?.blocked_by) && fields.blocked_by.some((entry) => entry?.item === waits.item)) return null;
+  return waits ?? null;
+}
+
 // Row line two: the id is the citation a reader types back, so the title gives
 // way to it, not the other way round (review G6).
 export function itemLine(item, product, lifecycle = 'active') {

package/work/lib/verbs.mjs

@@ -11,29 +11,61 @@
 // lock block L1, L2 and L3. Every write carries request_id and writer. The
 // server, not the caller, supplies the session. Unknown ids are refused.
 // M2 slice L1 adds the repo kind in 0.5.0, which carries 0.4.0 whole.
-// Stage 1 of the target design adds kinds, a list, in 0.6.0.
-import manifestCurrent from '../manifest-0.6.0.json' with { type: 'json' };
+// Stage 1 of the target design adds kinds, a list, in 0.6.0. The work item
+// additions add entry, the log of an item, in 0.7.0.
+import manifestCurrent from '../manifest-0.7.0.json' with { type: 'json' };
 import { EngramHttpError } from './client.mjs';
 import { VerbError, refuse, canonicalJson, sha256, text, oneOf, origin, url, stringList, LIVE_LIFECYCLES, REPO_KINDS, LIVE_KINDS, repoKinds, kindsFromArgs } from './verb-fields.mjs';
-import { createQuestionVerbs, COSTS, QUESTION_WRITE_VERBS, QUESTION_READ_VERBS } from './questions.mjs';
+import { createQuestionVerbs, COSTS, QUESTION_WRITE_VERBS, QUESTION_READ_VERBS, oneLine, scrubSecrets } from './questions.mjs';
 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 { 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 };
-export const MANIFEST_VERSION = '0.6.0';
+export const MANIFEST_VERSION = '0.7.0';
 export const PRODUCT_ID = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 export const REPO_ID = /^[A-Za-z0-9](?:[A-Za-z0-9_.-]{0,99})\/[A-Za-z0-9_.-]{1,100}$/;
 export const STAGES = Object.freeze(['capture', 'spec', 'build', 'verify', 'learn']);
 export const TIERS = Object.freeze(['hotfix', 'standard', 'initiative']);
 export const DRIVERS = Object.freeze(['owner-led', 'agent']);
 // What an item waits on (release 0.2.3). One line on the item, shown on its
-// rows. "item" names another work item by id.
-export const WAITS_ON = Object.freeze(['owner-decision', 'owner-action', 'item', 'gate', 'nothing']);
-const MAX_EDITS = 20;
+// rows. Work item additions, slice 2: "item" retires for new writes, and
+// item_block keeps the links. A record that already holds it still reads.
+export const WAITS_ON = Object.freeze(['owner-decision', 'owner-action', 'gate', 'nothing']);
+// How far the loop check of item_block walks before it stops.
+const MAX_BLOCK_WALK = 200;
+// Work item additions, slice 3. Engram refuses an entity whose fields hold
+// more than 64 KiB of UTF-8 (entity-write-bounds.ts). An item keeps its
+// newest MAX_RECEIPTS receipts. A diff leaves its receipt once its log entry
+// exists. If the whole record is still past FIELDS_LIMIT, the oldest diffs go
+// first, then the oldest receipts. The receipt of this request and the one
+// that made the item are never dropped: a retry needs them.
+const MAX_RECEIPTS = 100;
+const FIELDS_LIMIT = 56 * 1024;
+export function trimReceipts(fields, receipts, logged = new Set(), keep = null) {
+  const pinned = (id, receipt) => id === keep || receipt?.verb === 'item_propose';
+  let rows = Object.entries(receipts ?? {}).sort(([, a], [, b]) => String(a?.at ?? '').localeCompare(String(b?.at ?? '')));
+  while (rows.length > MAX_RECEIPTS) {
+    const index = rows.findIndex(([id, receipt]) => !pinned(id, receipt));
+    if (index < 0) break;
+    rows.splice(index, 1);
+  }
+  const bare = ([id, receipt]) => { const { change, note, ...rest } = receipt ?? {}; return [id, rest]; };
+  rows = rows.map((row) => (row[1]?.change && logged.has(row[0]) ? bare(row) : row));
+  const size = () => Buffer.byteLength(JSON.stringify({ ...fields, atlas_receipts: Object.fromEntries(rows) }));
+  for (let index = 0; index < rows.length && size() > FIELDS_LIMIT; index += 1) {
+    if (rows[index][1]?.change && rows[index][0] !== keep) rows[index] = bare(rows[index]);
+  }
+  for (let index = 0; index < rows.length && size() > FIELDS_LIMIT;) {
+    if (pinned(...rows[index])) index += 1;
+    else rows.splice(index, 1);
+  }
+  return Object.fromEntries(rows);
+}
 // The tags that other verbs own (work item additions, slice 1). item_edit
 // never adds or removes them; item_propose drops them from the caller's list.
-export const OWNED_TAG_PREFIXES = Object.freeze(['product:', 'repo:', 'tier:']);
+export const OWNED_TAG_PREFIXES = Object.freeze(['product:', 'repo:', 'tier:', 'item:']);
 export const OWNED_TAGS = Object.freeze(['atlas-work', 'no-model', 'atlas-registry']);
 // Engram reads no-model with the spaces trimmed and in any case, so the check
 // does the same: No-Model is owned too.
@@ -163,17 +195,32 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
   // recomputes it from the newer record. guard, when given, is checked again on
   // that newer record: a write that another writer made wrong is refused, not
   // forced through (release 0.2.3).
-  async function patch(entity, verb, requestId, fields, { tags, title, digest, guard } = {}) {
+  // An item verb (LOG_VERBS) puts the diff of its write into its own receipt,
+  // in the same write; run() then copies it into a log entry. note is a
+  // reason the log keeps beside the diff (work item additions, slice 3).
+  async function patch(entity, verb, requestId, fields, { tags, title, digest, guard, note, log = LOG_VERBS.includes(verb) } = {}) {
     let current = entity;
+    const logged = log ? await activity.loggedIds(entity.id) : undefined;
     for (let attempt = 0; attempt < 2; attempt += 1) {
       if (attempt > 0 && guard) guard(current);
       const next = typeof fields === 'function' ? fields(current) : fields;
-      const receipts = { ...(current.fields?.atlas_receipts ?? {}), [requestId]: { verb, at: now(), ...(digest ? { digest } : {}) } };
-      const body = { version: current.version, fields: { ...(current.fields ?? {}), ...next, writer: label, request_id: requestId, atlas_receipts: receipts } };
+      // A fields function returns null when the newest record already holds
+      // the change; then nothing is written.
+      if (next === null) return current;
       // tags as a function replaces the list with what it returns, computed
       // from the newest record; a list is added to the tags already there.
-      if (typeof tags === 'function') body.tags = [...new Set(tags(current))];
-      else if (tags) body.tags = [...new Set([...(current.tags ?? []), ...tags])];
+      let nextTags;
+      if (typeof tags === 'function') nextTags = [...new Set(tags(current))];
+      else if (tags) nextTags = [...new Set([...(current.tags ?? []), ...tags])];
+      const change = log ? diffOf(current, next, { title: title || undefined, tags: nextTags }) : null;
+      // A logged write that changes no field is not written: no receipt, no
+      // entry, no new version.
+      if (change && !Object.keys(change).length) return current;
+      const receipt = { verb, at: now(), ...(digest ? { digest } : {}), ...(change ? { change, ...(note ? { note: scrubSecrets(note).text } : {}) } : {}) };
+      const { atlas_receipts: _old, ...rest } = { ...(current.fields ?? {}), ...next, writer: label, request_id: requestId };
+      const receipts = trimReceipts(rest, { ...(current.fields?.atlas_receipts ?? {}), [requestId]: receipt }, logged, requestId);
+      const body = { version: current.version, fields: { ...rest, atlas_receipts: receipts } };
+      if (nextTags) body.tags = nextTags;
       if (title) body.title = title;
       try { await client.updateEntity(current.id, body); return client.getEntity(current.id); }
       catch (error) {
@@ -183,9 +230,9 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
       }
     }
   }
-  async function create(type, requestId, verb, { title, body, fields, tags, digest }) {
-    const receipt = await client.createEntity({ title, ...(body ? { body } : {}), type_id: type.id, fields: { ...fields, writer: label, request_id: requestId, atlas_receipts: { [requestId]: { verb, at: now(), ...(digest ? { digest } : {}) } } }, tags: [...new Set(['atlas-work', 'no-model', ...(tags ?? [])])] });
-    return client.getEntity(receipt.id);
+  async function create(type, requestId, verb, { title, body, fields, tags, digest, change, readBack = true }) {
+    const receipt = await client.createEntity({ title, ...(body ? { body } : {}), type_id: type.id, fields: { ...fields, writer: label, request_id: requestId, atlas_receipts: { [requestId]: { verb, at: now(), ...(digest ? { digest } : {}), ...(change ? { change } : {}) } } }, tags: [...new Set(['atlas-work', 'no-model', ...(tags ?? [])])] });
+    return readBack ? client.getEntity(receipt.id) : receipt;
   }
   async function edge(src, dst, suffix, requestId, props = {}) {
     const intent = await edgeIntent(suffix);
@@ -389,7 +436,7 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
       const type = await typeNamed('container');
       const prior = await landed(type, requestId, meta);
       if (prior) return { verb: 'item_propose', item_id: prior.id, version: prior.version, lifecycle: prior.fields.lifecycle, stage: prior.fields.stage, product: prior.fields.product, repos: prior.fields.repos, replayed_from_graph: true };
-      const entity = await create(type, requestId, 'item_propose', { digest: meta?.digest, title, body: args.body ? text(args.body, 'body') : undefined, fields, tags: [`product:${product.fields.registry_id}`, ...repos.map((id) => `repo:${id}`), `tier:${fields.tier}`, ...(args.tags ? stringList(args.tags, 'tags', { max: 16 }).filter((tag) => !isOwnedTag(tag)) : [])] });
+      const entity = await create(type, requestId, 'item_propose', { change: { created: { from: null, to: scrubSecrets(oneLine(title, 300)).text } }, digest: meta?.digest, title, body: args.body ? text(args.body, 'body') : undefined, fields, tags: [`product:${product.fields.registry_id}`, ...repos.map((id) => `repo:${id}`), `tier:${fields.tier}`, ...(args.tags ? stringList(args.tags, 'tags', { max: 16 }).filter((tag) => !isOwnedTag(tag)) : [])] });
       return { verb: 'item_propose', item_id: entity.id, version: entity.version, lifecycle: 'proposed', stage: 'capture', product: fields.product, repos };
     },
 
@@ -548,22 +595,17 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
       }
       if (args.next_step !== undefined) {
         change.next_step = text(args.next_step, 'next_step', { max: 1000 });
-        previous.next_step = fields.next_step ?? '';
       }
       if (args.waits_on !== undefined) {
         const given = args.waits_on;
-        if (!given || typeof given !== 'object' || Array.isArray(given)) refuse(`waits_on must be { on, note?, item? }, with on one of ${WAITS_ON.join(', ')}`);
+        if (!given || typeof given !== 'object' || Array.isArray(given)) refuse(`waits_on must be { on, note? }, with on one of ${WAITS_ON.join(', ')}`);
+        if (given.on === 'item') refuse('waits_on.on "item" is retired; link the items with item_block, which lists every blocker and shows "blocks" on the other row');
         const wait = { on: oneOf(given.on, 'waits_on.on', WAITS_ON) };
         const note = text(given.note, 'waits_on.note', { optional: true, max: 300 });
         if (note) wait.note = note;
-        if (wait.on === 'item') {
-          const other = await requireItem(given.item);
-          if (other.id === item.id) refuse('an item cannot wait on itself');
-          wait.item = other.id;
-        } else if (given.item !== undefined) refuse('waits_on.item is only for on: item');
-        if (wait.on !== 'nothing' && wait.on !== 'item' && !wait.note) refuse(`waits_on.note is required for on: ${wait.on}; say what exactly it waits on`);
+        if (given.item !== undefined) refuse('waits_on.item is retired; link the items with item_block');
+        if (wait.on !== 'nothing' && !wait.note) refuse(`waits_on.note is required for on: ${wait.on}; say what exactly it waits on`);
         change.waits_on = wait;
-        previous.waits_on = fields.waits_on ?? null;
       }
       const tagsAdd = args.tags_add === undefined ? [] : tagList(args.tags_add, 'tags_add');
       const tagsRemove = args.tags_remove === undefined ? [] : tagList(args.tags_remove, 'tags_remove');
@@ -596,18 +638,82 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
       if (tagEdit && sameList(tagsOf(item), item.tags ?? [])) tagEdit = false;
       if (args.title === undefined && !Object.keys(change).length && !tagEdit && !planGiven) return { verb: 'item_edit', item_id: item.id, version: item.version, title: item.title, next_step: fields.next_step ?? '', waits_on: fields.waits_on ?? null, tags: item.tags ?? [], plan: fields.plan ?? null, changed: [], unchanged: true };
       const reason = text(args.reason, 'reason', { optional: true, max: 1000 });
-      const at = now();
-      // The history keeps the last MAX_EDITS entries. The first title the
-      // owner gave is kept on its own, so a title never falls out of it. The
-      // old tags and dates come from the record the write lands on.
-      const entryOf = (current) => ({ at, by: label.agent, previous: { ...previous, ...(tagEdit ? { tags: current.tags ?? [] } : {}), ...(planGiven ? { plan: current.fields?.plan ?? null } : {}) }, ...(reason ? { reason } : {}) });
+      // Slice 3: the old values go into the diff in the receipt and then into
+      // a log entry, taken from the record the write lands on. edits stops
+      // growing and stays readable. The first title the owner gave is still
+      // kept on its own.
       const entity = await patch(item, 'item_edit', requestId, (current) => ({
-        ...change, ...(planGiven ? { plan: planOf(current) } : {}), edits: [...(Array.isArray(current.fields?.edits) ? current.fields.edits : []), entryOf(current)].slice(-MAX_EDITS),
+        ...change, ...(planGiven ? { plan: planOf(current) } : {}),
         ...(previous.title !== undefined && current.fields?.first_title === undefined ? { first_title: previous.title } : {}),
-      }), { digest: meta?.digest, guard: live, ...(title ? { title } : {}), ...(tagEdit ? { tags: tagsOf } : {}) });
+      }), { digest: meta?.digest, guard: live, note: reason, ...(title ? { title } : {}), ...(tagEdit ? { tags: tagsOf } : {}) });
       return { verb: 'item_edit', item_id: entity.id, version: entity.version, title: entity.title, next_step: entity.fields?.next_step ?? '', waits_on: entity.fields?.waits_on ?? null, tags: entity.tags ?? [], plan: entity.fields?.plan ?? null, changed: [...(args.title !== undefined ? ['title'] : []), ...Object.keys(change), ...(tagEdit ? ['tags'] : []), ...(planGiven ? ['plan'] : [])] };
     },
 
+    // Work item additions, slice 2: an item names the items that block it.
+    // The list on the item is the one home of the fact; a view works out
+    // "blocks" from the items it loaded. The lead keeps the links true, so no
+    // owner flag is needed. A link that would close a loop is refused.
+    async item_block(args, requestId, meta) {
+      const item = await requireItem(args.item_id);
+      text(args.blocked_by, 'blocked_by', { max: 200 });
+      const note = text(args.note, 'note', { optional: true, max: 300 });
+      const listOf = (record) => (Array.isArray(record.fields?.blocked_by) ? record.fields.blocked_by : []);
+      // The replay comes before the blocker is read: a blocker archived since
+      // the write landed must not refuse a write that already happened.
+      if (alreadyPatched(item, requestId, meta)) return { verb: 'item_block', item_id: item.id, version: item.version, blocked_by: listOf(item).map((entry) => entry.item), replayed_from_graph: true };
+      const blocker = await requireItem(args.blocked_by);
+      const live = (current) => { if (!LIVE_LIFECYCLES.includes(current.fields?.lifecycle)) refuse(`item ${current.id} is ${current.fields?.lifecycle}; only a proposed, active or paused item can be blocked`); };
+      live(item);
+      if (blocker.id === item.id) refuse('an item cannot block itself');
+      if (listOf(item).some((entry) => entry.item === blocker.id)) return { verb: 'item_block', item_id: item.id, version: item.version, blocked_by: listOf(item).map((entry) => entry.item), unchanged: true };
+      // Walk what the blocker waits on, with an old waits_on pointer to an
+      // item counted as a link. Reaching the item means the new link closes a
+      // loop. Two sessions can pass this check at the same moment;
+      // one owner runs these products, so the design accepts that.
+      const seen = new Set([blocker.id]);
+      const path = new Map([[blocker.id, [blocker.id]]]);
+      const queue = [blocker];
+      while (queue.length) {
+        const current = queue.shift();
+        const links = [...listOf(current), ...(current.fields?.waits_on?.on === 'item' && typeof current.fields.waits_on.item === 'string' ? [{ item: current.fields.waits_on.item }] : [])];
+        for (const entry of links) {
+          if (entry.item === item.id) refuse(`this link would close a loop: ${[item.id, ...path.get(current.id), item.id].join(' → ')}`);
+          if (seen.has(entry.item)) continue;
+          if (seen.size >= MAX_BLOCK_WALK) refuse(`the loop check stopped after ${MAX_BLOCK_WALK} items; the blocked-by chain is too long to check`);
+          seen.add(entry.item);
+          let next;
+          try { next = await client.getEntity(entry.item); } catch (error) { if (error instanceof EngramHttpError && error.status === 404) continue; throw error; }
+          path.set(next.id, [...path.get(current.id), next.id]);
+          queue.push(next);
+        }
+      }
+      const at = now();
+      const link = { item: blocker.id, at, by: label.agent, ...(note ? { note } : {}) };
+      // null tells patch() not to write: another session added the same link.
+      const entity = await patch(item, 'item_block', requestId, (current) => (listOf(current).some((entry) => entry.item === blocker.id) ? null : { blocked_by: [...listOf(current), link] }), { digest: meta?.digest, guard: live });
+      return { verb: 'item_block', item_id: entity.id, version: entity.version, blocked_by: listOf(entity).map((entry) => entry.item), ...(entity.fields?.atlas_receipts?.[requestId] ? {} : { unchanged: true }) };
+    },
+
+    async item_unblock(args, requestId, meta) {
+      const item = await requireItem(args.item_id);
+      text(args.blocked_by, 'blocked_by', { max: 200 });
+      const reason = text(args.reason, 'reason', { optional: true, max: 1000 });
+      const listOf = (record) => (Array.isArray(record.fields?.blocked_by) ? record.fields.blocked_by : []);
+      if (alreadyPatched(item, requestId, meta)) return { verb: 'item_unblock', item_id: item.id, version: item.version, blocked_by: listOf(item).map((entry) => entry.item), removed: args.blocked_by, replayed_from_graph: true };
+      // Live and still blocked, on the first read and on the newest record.
+      const guard = (current) => {
+        if (!LIVE_LIFECYCLES.includes(current.fields?.lifecycle)) refuse(`item ${current.id} is ${current.fields?.lifecycle}; only a proposed, active or paused item can be unblocked`);
+        if (!listOf(current).some((entry) => entry.item === args.blocked_by)) refuse(`item ${current.id} is not blocked by ${args.blocked_by}`);
+      };
+      guard(item);
+      // The diff keeps the removed link, taken from the record the write
+      // lands on, so the log shows it (slice 3).
+      const entity = await patch(item, 'item_unblock', requestId, (current) => ({
+        blocked_by: listOf(current).filter((row) => row.item !== args.blocked_by),
+      }), { digest: meta?.digest, guard, note: reason });
+      return { verb: 'item_unblock', item_id: entity.id, version: entity.version, blocked_by: listOf(entity).map((row) => row.item), removed: args.blocked_by };
+    },
+
     async item_stage(args, requestId, meta) {
       const item = await requireItem(args.item_id);
       const stage = oneOf(args.stage, 'stage', STAGES);
@@ -645,9 +751,11 @@ 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 }));
+  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_stage', 'item_link', ...QUESTION_WRITE_VERBS, ...DELIVERY_WRITE_VERBS, ...SWEEP_WRITE_VERBS]);
-  const READ_VERBS = Object.freeze(['registry_list', ...QUESTION_READ_VERBS, ...DELIVERY_READ_VERBS, ...CAPABILITY_READ_VERBS, ...SWEEP_READ_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]);
 
   async function run(verb, args = {}) {
     if (!verbs[verb]) refuse(`unknown verb: ${verb}`);
@@ -674,6 +782,12 @@ export function createVerbs({ client, store, writer, session, agent = 'lead', bo
         await store.put(requestId, { ...record, phase: 'interrupted', error: error.message });
         throw error;
       }
+      // The item write landed. Its diff goes into a log entry now, best
+      // effort: a failure is a warning on the result (slice 3, step 6).
+      if (ENTRY_VERBS.includes(verb) && typeof result?.item_id === 'string') {
+        const warning = await activity.logEntries(result.item_id, requestId);
+        if (warning) result = { ...result, warning };
+      }
       await store.put(requestId, { ...record, phase: 'complete', result, completed_at: now() });
       return { ...copy(result), request_id: requestId, writer: label };
     });

package/work/{manifest-0.6.0.json → manifest-0.7.0.json}

@@ -1,8 +1,8 @@
 {
   "name": "atlas-work",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "kind": "extension",
-  "description": "Atlas work records: products and repos as the registry, work items, questions, decisions, receipts, delivery and reopen marks, and their relations. Version 0.6.0 adds kinds, a list, on the repo. Version 0.5.0 added the repo kind. Version 0.4.0 adds mark, the delivery fields on the item and the health endpoint on the product (M1 slice L3, 2026-09-17). Version 0.3.0 added question and receipt. Version 0.2.0 dropped atlas_key and write_class.",
+  "description": "Atlas work records: products and repos as the registry, work items, questions, decisions, receipts, delivery and reopen marks, and their relations. Version 0.7.0 adds entry, the log of an item: comments and the changes the item verbs make. Version 0.6.0 added kinds, a list, on the repo. Version 0.5.0 added the repo kind. Version 0.4.0 adds mark, the delivery fields on the item and the health endpoint on the product (M1 slice L3, 2026-09-17). Version 0.3.0 added question and receipt. Version 0.2.0 dropped atlas_key and write_class.",
   "capability": {
     "semantics_version": ">=1.0.0 <2.0.0"
   },
@@ -15,6 +15,7 @@
       "@{{handle}}/question",
       "@{{handle}}/receipt",
       "@{{handle}}/mark",
+      "@{{handle}}/entry",
       "@{{handle}}/part_of",
       "@{{handle}}/spun_out_of",
       "@{{handle}}/replaced_by",
@@ -430,6 +431,73 @@
           }
         }
       },
+      {
+        "name": "@{{handle}}/entry",
+        "kind": "entity",
+        "component_spec": {
+          "metadata": {
+            "fields": {
+              "$required": [
+                "item",
+                "kind",
+                "at",
+                "writer",
+                "request_id"
+              ],
+              "properties": {
+                "item": {
+                  "type": "string"
+                },
+                "product": {
+                  "type": "string"
+                },
+                "kind": {
+                  "type": "string",
+                  "enum": [
+                    "comment",
+                    "change"
+                  ]
+                },
+                "voice": {
+                  "type": "string",
+                  "enum": [
+                    "agent",
+                    "owner"
+                  ]
+                },
+                "text": {
+                  "type": "string"
+                },
+                "corrects": {
+                  "type": "string"
+                },
+                "redactions": {
+                  "type": "number"
+                },
+                "verb": {
+                  "type": "string"
+                },
+                "change": {
+                  "type": "object"
+                },
+                "at": {
+                  "type": "string"
+                },
+                "writer": {
+                  "type": "object"
+                },
+                "request_id": {
+                  "type": "string"
+                },
+                "atlas_receipts": {
+                  "type": "object"
+                }
+              }
+            },
+            "validation": "strict"
+          }
+        }
+      },
       {
         "name": "@{{handle}}/part_of",
         "kind": "edge",
@@ -610,6 +678,10 @@
     ],
     "0.6.0": [
       "Added: kinds on the repo record, a list of what the repo is (service, library, schema, cli, plugin). A monorepo or a plugin that is also a library holds more than one. The scalar kind stays, so a record written under 0.5.0 still validates and an older reader still reads it. Stage 1 of the target design."
+    ],
+    "0.7.0": [
+      "Adds entry: one record for each comment on a work item and for each change an item verb makes. It carries the tag item:<id>, so one list by type and tag finds every entry of an item. A comment holds its voice, agent or owner, its text and the comment it corrects. A change holds the verb and each changed field as from and to. Work item additions, slice 3.",
+      "Nothing else changes. Every record type of 0.6.0 is carried over whole, so every record written under 0.6.0 still validates."
     ]
   }
 }

package/work/mcp.mjs

@@ -40,7 +40,7 @@ const CODE_DIGEST = { type: 'object', description: 'One sub-agent digest for one
 
 export const TOOLS = [
   { name: 'registry_list', description: `List the registered products and their repos with registry ids and entity ids. When: before any item verb, to find the ids to pass. Scope: read, no owner flag needed. ${RULES}`, inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-  { name: 'setup', description: `Publish atlas-work ${MANIFEST_VERSION} to the tenant's Forge and register its types (product, repo with its kinds, container, decision, question, receipt, mark and the surviving edges). Idempotent. When: once per tenant, before the first product add, and again after a manifest change. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id'], properties: { request_id: REQUEST_ID }, additionalProperties: false } },
+  { name: 'setup', description: `Publish atlas-work ${MANIFEST_VERSION} to the tenant's Forge and register its types (product, repo with its kinds, container, decision, question, receipt, mark, entry and the surviving edges). Idempotent. When: once per tenant, before the first product add, and again after a manifest change. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id'], properties: { request_id: REQUEST_ID }, additionalProperties: false } },
   { name: 'product_add', description: `Register a product in the name registry. Refuses when the id exists. When: a product gets its first work item. Owner present only. registry_id is a lowercase slug and is immutable. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'registry_id', 'name'], properties: { request_id: REQUEST_ID, registry_id: S('Lowercase slug, for example "engram". Immutable.'), name: S('Display name.'), project_id: S('Entity id of the existing Engram project entity this product links to.'), health_url: S('Absolute https URL of the deployed app\'s health endpoint. The done verb reads the deployed commit there, and every live check must be on this origin.'), check_paths: { type: 'array', items: { type: 'string' }, description: 'Absolute paths on that origin the functional check of item_done may read, for example ["/v1/housekeeping"]. Unset, the check may read only the health endpoint\'s own path.' }, notes: S('Free text.') }, additionalProperties: false } },
   { name: 'product_edit', description: `Change a product's name, notes, health endpoint, check paths, design hub link or project link. Refuses an unknown id. The registry id never changes. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'registry_id'], properties: { request_id: REQUEST_ID, registry_id: S('Existing product id.'), name: S('New display name.'), project_id: S('Entity id of an Engram project entity.'), health_url: S('Absolute https URL of the deployed app\'s health endpoint.'), check_paths: { type: 'array', items: { type: 'string' }, description: 'Absolute paths the functional check of item_done may read on that origin.' }, design_hub_url: S('Absolute https URL of the one pinned "Design docs" hub page. Set it once, on any product; registry_list and design_index return it.'), notes: S('Free text.') }, additionalProperties: false } },
   { name: 'repo_add', description: `Register a GitHub repo under a product. The server reads GitHub itself: the id must equal the repo's full name and the owner must have push rights, or the add is refused. The default branch comes from GitHub. The kinds say what the repo is; item_done reads them to choose how a delivery is proved. Give kinds, a list; kind, one value, is the older form. Refuses an unknown product id and an existing repo id; repo ids are immutable. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'registry_id', 'product'], properties: { request_id: REQUEST_ID, registry_id: S('GitHub "owner/repo", exact spelling.'), product: S('Existing product id.'), kinds: KINDS, kind: S(`The older form: one kind. One of ${REPO_KINDS.join(', ')}. Give kinds instead.`), notes: S('Free text.') }, additionalProperties: false } },
@@ -51,8 +51,12 @@ export const TOOLS = [
   { name: 'item_park', description: `Park an item: lifecycle paused with the reason. Paused items are backlog: the in_flight rows leave them out, and needs_me still shows their open questions. Refuses a missing reason. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'reason'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), reason: S('Why it is parked.') }, additionalProperties: false } },
   { name: 'item_resume', description: `Resume a parked item to its earlier lifecycle with a reason. It also undoes a drop: a dropped item goes back to the lifecycle it left, and the drop's words stay on it. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'reason'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), reason: S('Why it resumes.') }, additionalProperties: false } },
   { name: 'item_drop', description: `Drop an item in the owner's words: lifecycle dropped, with the words, the date and the lifecycle it left. A dropped item stays in the graph, and no live view lists it. Refuses a done item (reopen it instead) and an item already dropped. When: the owner retires a piece of work. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'origin'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), origin: { ...ORIGIN, description: "The owner's words that drop the item, verbatim, with where and when they were said." } }, additionalProperties: false } },
-  { name: 'item_edit', description: `Edit a proposed, active or paused item: its next step, what it waits on, its free tags, its planned dates, or its title. Each edit appends the old values to the item's edits, and the last 20 are kept; the first title stays in first_title. When: the next step, the wait or a tag changes; the lead keeps them true at the end of each session. No owner flag for next_step, waits_on and tags; the tags that other verbs own (product:, repo:, tier:, atlas-work, no-model, atlas-registry) are refused. A new title is the owner's words, and planned dates are the owner's promise, so both need the owner present. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), next_step: S('One line: what happens next.'), waits_on: { type: 'object', required: ['on'], description: 'What the item waits on. Shown on its rows.', properties: { on: S(`One of ${WAITS_ON.join(', ')}.`), note: S('What exactly it waits on, in plain words. Required unless on is item or nothing.'), item: S('The item id it waits on, for on: item.') } }, title: S("A new title, in the owner's words. Owner present only."), tags_add: { type: 'array', items: { type: 'string' }, description: 'Free tags to add.' }, tags_remove: { type: 'array', items: { type: 'string' }, description: 'Free tags to remove.' }, plan: { type: 'object', description: 'Planned dates, set by the owner. Owner present only. Each is YYYY-MM-DD, or null to clear it. Dates not named stay as they are.', properties: { start: { type: ['string', 'null'], description: 'Planned start.' }, end: { type: ['string', 'null'], description: 'Planned end. Not before the start.' }, deadline: { type: ['string', 'null'], description: 'Deadline.' } }, additionalProperties: false }, reason: S('One line on why it changed.') }, additionalProperties: false } },
+  { name: 'item_edit', description: `Edit a proposed, active or paused item: its next step, what it waits on, its free tags, its planned dates, or its title. Each edit keeps the old and new values in the item's log, which item_activity reads; the first title stays in first_title. When: the next step, the wait or a tag changes; the lead keeps them true at the end of each session. No owner flag for next_step, waits_on and tags; the tags that other verbs own (product:, repo:, tier:, item:, atlas-work, no-model, atlas-registry) are refused, in any case. A new title is the owner's words, and planned dates are the owner's promise, so both need the owner present. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), next_step: S('One line: what happens next.'), waits_on: { type: 'object', required: ['on'], description: 'What the item waits on. Shown on its rows.', properties: { on: S(`One of ${WAITS_ON.join(', ')}. To wait on another item, use item_block.`), note: S('What exactly it waits on, in plain words. Required unless on is nothing.') } }, title: S("A new title, in the owner's words. Owner present only."), tags_add: { type: 'array', items: { type: 'string' }, description: 'Free tags to add.' }, tags_remove: { type: 'array', items: { type: 'string' }, description: 'Free tags to remove.' }, plan: { type: 'object', description: 'Planned dates, set by the owner. Owner present only. Each is YYYY-MM-DD, or null to clear it. Dates not named stay as they are.', properties: { start: { type: ['string', 'null'], description: 'Planned start.' }, end: { type: ['string', 'null'], description: 'Planned end. Not before the start.' }, deadline: { type: ['string', 'null'], description: 'Deadline.' } }, additionalProperties: false }, reason: S('One line on why it changed.') }, additionalProperties: false } },
   { name: 'item_stage', description: `Move an active item to a stage (${STAGES.join(', ')}). When: work moves; the lead or the delivering agent calls it. No owner flag needed. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'stage'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), stage: S(`One of ${STAGES.join(', ')}.`), note: S('One line on what moved.') }, additionalProperties: false } },
+  { name: 'item_block', description: `Record that an item is blocked by another item. The item keeps a list of its blockers, each with a note; the views show "blocked by" on its row and "blocks" on the blocker's row, and a blocker that is delivered or dropped shows as cleared. Refuses the item itself and a link that would close a loop. When: work cannot move until another item lands. No owner flag needed. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'blocked_by'], properties: { request_id: REQUEST_ID, item_id: S('The blocked item id.'), blocked_by: S('The item id that blocks it.'), note: S('One line: what exactly it needs from the blocker.') }, additionalProperties: false } },
+  { name: 'item_unblock', description: `Remove one blocked-by link from an item. The removed link stays in the item's log. When: the blocker no longer holds the item back. No owner flag needed. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'blocked_by'], properties: { request_id: REQUEST_ID, item_id: S('The blocked item id.'), blocked_by: S('The blocker item id to remove.'), reason: S('One line on why.') }, additionalProperties: false } },
+  { name: 'item_comment', description: `Add a comment to an item's log: a running note from the lead, or the owner's own words. A comment is never edited; to correct one, add a new comment that names it in corrects. The text goes through the secret filter. When: something about the item is worth keeping that no other verb records. No owner flag for the agent's voice; the owner's voice is his words, word for word, so it needs the owner present. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'text'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), text: S('The comment, at most 4000 characters.'), voice: S('agent (the default) or owner. owner means the text is the owner\'s own words. Owner present only.'), corrects: S('The entry id of an earlier comment on this item that this one corrects.') }, additionalProperties: false } },
+  { name: 'item_activity', description: 'Answer "what happened on this item?". One list, newest first: the comments, each change an item verb made with its old and new values, the questions, the decisions, the delivery marks, the pieces and the links. A write that kept no values, such as one from before manifest 0.7.0, shows its verb and time with "no values recorded". The edits kept on the item before 0.7.0 show too. Scope: read, no owner flag needed.', inputSchema: { type: 'object', required: ['item_id'], properties: { item_id: S('Item id.'), limit: { type: 'integer', minimum: 1, maximum: 200, description: 'How many rows, newest first. Default 50.' } }, additionalProperties: false } },
   { name: 'item_link', description: `Attach a typed link (kind, url, role, note) to an item: a PR, an issue, an artifact, a design doc, a conversation. When: any in-session agent has a link the item should carry, for example a PR it opened. No owner flag needed. A duplicate kind and url is a no-op. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'kind', 'url'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), kind: S(`One of ${LINK_KINDS.join(', ')}.`), url: S('Absolute http or https URL.'), role: S('What the link is to the item, for example "delivers", "design", "evidence".'), note: S('One line.') }, additionalProperties: false } },
   { name: 'item_adopt', description: `Give an existing work item its product and repos. This is the slice L5 sweep: most items in the tenant were made before the registry existed and name no product, so no view can place them. Refuses an item that already names another registered product; an item is named once. The audit stamps adopted_at and adopted_from move only when the product actually changes. When: the owner says which product a piece of work belongs to. Owner present only. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'item_id', 'product', 'repos'], properties: { request_id: REQUEST_ID, item_id: S('Item id.'), product: S('Product id the item belongs to.'), repos: { type: 'array', items: { type: 'string' }, description: 'Repo ids under that product. Required. Pass an empty list for an item that has no repo, such as a container root; a repo of another product is dropped and named in dropped_repos.' }, stage: S(`One of ${STAGES.join(', ')}. Active items only.`), tier: S(`One of ${TIERS.join(', ')}.`), driver: S(`One of ${DRIVERS.join(', ')}.`), next_step: S('One line: what happens next.') }, additionalProperties: false } },
   { name: 'question_ask', description: `Ask the owner one question that blocks work on an item, and say what waiting costs. When: an agent is blocked and cannot decide by itself. Any in-session agent may call it; no owner flag. The question shows in the "Needs me" view until it is answered. ${RULES}`, inputSchema: { type: 'object', required: ['request_id', 'text', 'item_id', 'product', 'cost'], properties: { request_id: REQUEST_ID, text: S('The question, in plain words, answerable without opening a source.'), item_id: S('Entity id of the work item the question blocks.'), product: S('Product id of that item.'), cost: S(`What waiting costs. One of: ${COSTS.map((cost) => `${cost} (${COST_MEANING[cost]})`).join('; ')}.`), context: { type: 'object', description: 'What the owner needs to answer without opening a source.', properties: { current_behavior: S('What happens today.'), change: S('What would change.'), affected: { type: 'array', items: { type: 'string' }, description: 'Parts that change.' }, options: { type: 'array', items: { type: 'string' }, description: 'The options, one per entry.' }, consequences: S('What follows from each option.'), sources: { type: 'array', items: { type: 'string' }, description: 'Absolute http or https URLs that back the context.' } } } }, additionalProperties: false } },