Skip to content

Autonomous development for real products. Governed agents build from specs you approve, follow the rules you set, and nothing merges until another agent proves it. Your decisions, judgement and taste are the bar that work must clear. Declare your vision and let agents build it.

feat(activity): deliver interrupts and break-time summaries [R2,N26,H16]

Corey Olson66ea56521929
diff --git a/src/activity-delivery-cli.js b/src/activity-delivery-cli.js
new file mode 100644
index 00000000..bf370bd8
--- /dev/null
+++ b/src/activity-delivery-cli.js
@@ -0,0 +1,60 @@
+/** Inbox and successful-submit delivery share one canonical receipt path [R2,N26,H16]. */
+import * as store from './board.js';
+import { readActivityDelivery } from './activity-delivery-read.js';
+import { activityMainFiles, activityWorkingFiles, readActivityCursor, saveActivityCursor } from './activity-inbox.js';
+import { agentDisplayName, evidenceLine, ordered, whoAmI, withBoard } from './cli.js';
+
+/** Render digest counts, actionable references and direct coordination without expanding digest bodies. */
+export function activityDeliveryLines({ shouts, agents, activity }, config) {
+ const lines = [];
+ for (const shout of shouts) {
+ const ask = shout.shout_decision ? `asks for a decision (#${shout.shout_id}; pullboard answer ${shout.shout_id} "..."): ` : '';
+ const reply = shout.shout_answers ? `answers #${shout.shout_answers}: ` : '';
+ lines.push(`${shout.shout_at.slice(0, 16)} ${agentDisplayName(agents, config, shout.shout_from)} -> ${agentDisplayName(agents, config, shout.shout_to)}: ${ask}${reply}${shout.shout_text}`);
+ if (shout.shout_evidence_kind) lines.push(` ${evidenceLine(shout)}`);
+ }
+ for (const interrupt of activity.interrupts) lines.push(`interrupt ${interrupt.id}: ${interrupt.text}`);
+ const direct = new Set(shouts.map(shout => shout.shout_id));
+ for (const entry of activity.entries) if (!direct.has(entry.shout)) lines.push(`${entry.at.slice(0, 16)} ${entry.text}`);
+ for (const digest of activity.digests) lines.push(digest.text);
+ if (!lines.length) lines.push('no new shouts or activity');
+ return lines;
+}
+
+/** Persist bounded batches without advancing past an interrupt that a later batch has not yet recorded. */
+async function recordIncluded(ctx, board, agentId, observation) {
+ const groups = [];
+ for (let offset = 0; offset < observation.fresh.length; offset += 1000) groups.push(observation.fresh.slice(offset, offset + 1000));
+ if (!groups.length) groups.push([]);
+ for (const [index, interrupts] of groups.entries()) {
+ const remaining = groups.slice(index + 1).flat().map(interrupt => interrupt.eventId).filter(Number.isSafeInteger);
+ const through = remaining.length ? Math.min(observation.through, Math.min(...remaining) - 1) : observation.through;
+ await ordered(ctx, board, 'recordActivityDelivery', [{ agentId, interrupts, through,
+ observedThrough: observation.observedThrough,
+ ...(index === groups.length - 1 && observation.digestThrough !== undefined ? { digestThrough: observation.digestThrough } : {}) }]);
+ }
+}
+
+/** Delivery records included interrupts; explicit recipient acknowledgement is a separate move. */
+export async function deliverActivity(ctx, { actedIds = [], afterSubmit = false, directShouts = true } = {}) {
+ const delivered = await withBoard(ctx, async board => {
+ const me = whoAmI(ctx, board);
+ if (actedIds.length) await ordered(ctx, board, 'actOnActivity', [{ agentId: me.id, ids: actedIds }]);
+ const local = readActivityCursor(ctx.info.root, me.id, store.boardId(board));
+ const projected = readActivityDelivery(board, me.id, { sessionStart: local.sessionStart, afterSubmit,
+ workingFiles: builds => activityWorkingFiles(ctx.info.root, builds),
+ changesForMain: (commit, detail) => activityMainFiles(ctx.info.root, commit, detail,
+ { rowFiles: [ctx.config.spec, ctx.config.practice] }) });
+ const { observation, newsShouts, shoutCursor, ...activity } = projected;
+ const shouts = directShouts ? store.inbox(board, me.id, { through: shoutCursor })
+ .filter(shout => !newsShouts.includes(shout.shout_id)) : [];
+ // Pending obligations survive an output failure: delivery is not acknowledgement.
+ await recordIncluded(ctx, board, me.id, observation);
+ return { shouts, agents: store.listAgents(board), activity, local };
+ });
+ if (!saveActivityCursor(delivered.local, delivered.activity.cursor)) {
+ ctx.io.err('activity cursor could not be saved; activity may repeat when you read inbox again');
+ }
+ const { local, ...result } = delivered;
+ return result;
+}
diff --git a/src/activity-delivery-store.js b/src/activity-delivery-store.js
index ef8a77e4..b35f9e63 100644
--- a/src/activity-delivery-store.js
+++ b/src/activity-delivery-store.js
@@ -53,7 +53,7 @@ function canonicalInterrupt(board, agentId, input, observedThrough) {
throw new Refused('STALE_ACTIVITY_RECEIPT', 'the claim changed; read inbox again before recording its delivery');
}
return { id: input.id, reason: input.reason, kind: 'claim', item: item.item_id,
- leaseUntil: item.item_lease_until, text: `#${item.item_id} claim is lapsing; renew or release it` };
+ leaseUntil: item.item_lease_until, text: `#${item.item_id} claim lease ${item.item_lease_until} needed attention; acknowledge only after acting` };
}
if (!Number.isSafeInteger(input.eventId) || input.eventId < 1 || input.eventId > observedThrough || input.id !== `event:${input.eventId}`) {
throw new Refused('BAD_ACTIVITY_RECEIPT', 'an interrupt must name an observed native event; read inbox again');
@@ -68,16 +68,21 @@ function canonicalInterrupt(board, agentId, input, observedThrough) {
const question = answer && board.db.prepare('SELECT * FROM shout WHERE shout_id=?').get(answer.shout_answers);
if (question?.shout_from === agentId && question.shout_decision) text = `question #${question.shout_id} was answered; read answer #${answer.shout_id}`;
} else if (input.reason === 'files-changed' && event?.event_kind === 'main-moved') {
- if (!Array.isArray(input.files) || !input.files.length || input.files.some(path => typeof path !== 'string' || !path || path.length > 4096)) {
+ const files = input.files ?? [];
+ if (!Array.isArray(files) || !files.length && input.unknownFiles !== true && input.unknownAdditionalFiles !== true
+ || files.some(path => typeof path !== 'string' || !path || path.length > 4096)) {
throw new Refused('BAD_ACTIVITY_RECEIPT', 'a file interrupt needs its observed Git paths; read inbox again');
}
// Paths describe the recipient's Git observation. They grant no board or file authority.
- text = `main changed ${new Set(input.files).size} files you are editing; inspect the recorded main change`;
+ text = input.unknownFiles || input.unknownAdditionalFiles
+ ? 'main changed; some working-file overlap is unknown; inspect the recorded main change'
+ : `main changed ${new Set(input.files).size} files you are editing; inspect the recorded main change`;
}
if (!text) throw new Refused('BAD_ACTIVITY_RECEIPT', 'that event is not this seat\'s interrupt; read your own inbox');
return { id: input.id, eventId: event.event_id, at: event.event_at, by: event.event_by,
reason: input.reason, kind: event.event_kind, ...(event.item_id === null ? {} : { item: event.item_id }),
- ...(input.reason === 'files-changed' ? { files: [...new Set(input.files)].toSorted() } : {}), text };
+ ...(input.reason === 'files-changed' ? { files: [...new Set(input.files ?? [])].toSorted(), ...(input.unknownFiles ? { unknownFiles: true } : {}),
+ ...(input.unknownAdditionalFiles ? { unknownAdditionalFiles: true } : {}) } : {}), text };
}
/** Record only actually included interrupts, once; withheld and later events stay available. */
diff --git a/src/activity-delivery.js b/src/activity-delivery.js
index b45d9137..860ae553 100644
--- a/src/activity-delivery.js
+++ b/src/activity-delivery.js
@@ -12,7 +12,7 @@ export function classifyActivityDelivery({ agentId, items, activity, shouts, at
for (const entry of activity.entries) {
let reason;
if (entry.kind === 'reject' && entry.recipient === agentId) reason = 'rejected';
- else if (entry.kind === 'main-moved' && entry.files?.length) reason = 'files-changed';
+ else if (entry.kind === 'main-moved' && (entry.files?.length || entry.unknownFiles || entry.unknownAdditionalFiles)) reason = 'files-changed';
else if (entry.kind === 'answer') {
const reply = byShout.get(entry.shout);
const question = byShout.get(reply?.shout_answers);
diff --git a/src/cli-main.js b/src/cli-main.js
index 5d960fad..a1144c5c 100644
--- a/src/cli-main.js
+++ b/src/cli-main.js
@@ -101,6 +101,7 @@ const OPTIONS = {
'agent-mid': { type: 'string' },
'agent-strong': { type: 'string' },
attempts: { type: 'string' },
+ 'acted-on': { type: 'string' },
minutes: { type: 'string' },
items: { type: 'string' },
run: { type: 'string' },
diff --git a/src/cli.js b/src/cli.js
index d83617d7..bbc92610 100644
--- a/src/cli.js
+++ b/src/cli.js
@@ -1263,11 +1263,14 @@ export function refuseUncommittedSetup(mainRoot, config) {
/** Report and pin the original submitted commit, including a recovered acknowledged outcome. */
-export function reportSubmission(ctx, id, commit, gate, doctrine = []) {
+export async function reportSubmission(ctx, id, commit, gate, doctrine = []) {
const { root } = ctx.info;
const pin = `refs/pullboard/items/${id}/${commit.slice(0, 12)}`;
git(root, ['update-ref', pin, commit]);
- ctx.io.result?.({ id, commit, pin, gate, ...(doctrine.length ? { doctrine } : {}) });
+ const { deliverActivity, activityDeliveryLines } = await import('./activity-delivery-cli.js');
+ const delivery = await deliverActivity(ctx, { afterSubmit: true, directShouts: false });
+ ctx.io.result?.({ id, commit, pin, gate, activity: delivery.activity, ...(doctrine.length ? { doctrine } : {}) });
+ for (const line of activityDeliveryLines(delivery, ctx.config)) ctx.io.say(line);
ctx.io.say(`submitted #${id} at ${commit.slice(0, 12)}; ${gate.report}`);
ctx.io.say(`pinned as ${pin}, so this work can't be lost; keep your worktree until it is merged`);
ctx.io.say(`next: ${reviewerStartup(primaryCheckoutRoot(ctx.info), ctx.config, id)}`);
diff --git a/src/commands/inbox.js b/src/commands/inbox.js
index 2c9d332f..ef592d9f 100644
--- a/src/commands/inbox.js
+++ b/src/commands/inbox.js
@@ -1,47 +1,14 @@
-import {
- activityMainFiles,
- activityWorkingFiles,
- readActivityCursor,
- saveActivityCursor,
-} from '../activity-inbox.js';
-/** The pullboard inbox command, in its own module so an item adding another command never edits these lines. */
-import * as store from '../board.js';
-import {
- agentDisplayName,
- context,
- evidenceLine,
- whoAmI,
- withBoard,
-} from '../cli.js';
+/** The pullboard inbox command separates canonical interrupts from break-time summaries [R2,N26]. */
+import { activityDeliveryLines, deliverActivity } from '../activity-delivery-cli.js';
+import { context } from '../cli.js';
-/** Run `pullboard inbox` and return its exit code. */
-export function run(io) {
+/** Read the feed, or explicitly mark only this recipient's delivered interrupt ids acted on. */
+export async function run(io, { values = {} } = {}) {
const ctx = context(io);
- const { shouts, agents, activity, delivery } = withBoard(ctx, (board) => {
- const me = whoAmI(ctx, board);
- const delivery = readActivityCursor(ctx.info.root, me.id, store.boardId(board));
- const projected = store.agentActivity(board, me.id, { after: delivery.after, newsAfter: delivery.newsAfter,
- sessionStart: delivery.sessionStart,
- workingFiles: builds => activityWorkingFiles(ctx.info.root, builds),
- changesForMain: (commit, detail) => activityMainFiles(ctx.info.root, commit, detail,
- { rowFiles: [ctx.config.spec, ctx.config.practice] }) });
- const { newsShouts, shoutCursor, ...activity } = projected;
- return { shouts: store.inbox(board, me.id, { through: shoutCursor }).filter(shout => !newsShouts.includes(shout.shout_id)),
- agents: store.listAgents(board), activity, delivery };
- });
- io.result?.({ shouts, activity });
- if (!shouts.length && !activity.entries.length && !activity.digests.length) io.say('no new shouts or activity');
- for (const shout of shouts) {
- const ask = shout.shout_decision ? `asks for a decision (#${shout.shout_id}; pullboard answer ${shout.shout_id} "..."): ` : '';
- const reply = shout.shout_answers ? `answers #${shout.shout_answers}: ` : '';
- const from = agentDisplayName(agents, ctx.config, shout.shout_from);
- const to = agentDisplayName(agents, ctx.config, shout.shout_to);
- io.say(`${shout.shout_at.slice(0, 16)} ${from} -> ${to}: ${ask}${reply}${shout.shout_text}`);
- if (shout.shout_evidence_kind) io.say(` ${evidenceLine(shout)}`);
- }
- const delivered = new Set(shouts.map(shout => shout.shout_id));
- for (const entry of activity.entries) if (!delivered.has(entry.shout)) io.say(`${entry.at.slice(0, 16)} ${entry.text}`);
- for (const digest of activity.digests) io.say(digest.text);
- if (!saveActivityCursor(delivery, activity.cursor)) io.err('activity cursor could not be saved; activity may repeat when you read inbox again');
+ const actedIds = (values['acted-on'] ?? '').split(',').filter(Boolean);
+ const result = await deliverActivity(ctx, { actedIds });
+ const { agents, ...document } = result;
+ io.result?.(document);
+ for (const line of activityDeliveryLines(result, ctx.config)) io.say(line);
return 0;
}
diff --git a/src/help.js b/src/help.js
index 95a987c9..72a49a72 100644
--- a/src/help.js
+++ b/src/help.js
@@ -153,6 +153,7 @@ Work
a verdict takes --implies <ids>; a later verdict on the item supersedes it
any --note can be --note-file <file>, which keeps quotes, $ and backticks intact
pullboard shout <lane|agent|person|all> <text> pullboard inbox
+ pullboard inbox --acted-on <interrupt-ids> acknowledge comma-separated ids only after acting; reading is not acting
pullboard shout --item <id> <text> message the item builder, reviewer and coordinator
A seat shout to all reaches only coordinator and person; their broadcasts reach everyone.
pullboard shout all <text> --news coordinator/person release or focus news, digested at session start
@@ -351,7 +352,7 @@ const HELP_ALIASES = {
lane: { usage: 'pullboard lane add <name> --owns <path>[,<path>]', source: 'lane add' },
status: { usage: 'pullboard status', source: 'whoami' },
done: { usage: 'pullboard done <id>', source: 'submit <id>' },
- inbox: { usage: 'pullboard inbox', source: null },
+ inbox: { usage: 'pullboard inbox', source: null, extraFlags: ['--acted-on <interrupt-ids>'] },
'check accept': { usage: 'pullboard check accept <id>', source: 'check accept' },
relay: { source: 'relay', every: true },
lifecycle: { usage: 'pullboard lifecycle', source: null },
diff --git a/src/recorded-move.js b/src/recorded-move.js
index 187175dd..27da8b43 100644
--- a/src/recorded-move.js
+++ b/src/recorded-move.js
@@ -28,6 +28,7 @@ export function requestedCommandMove(command, operation) {
refreeze: ['refreeze'], reopen: ['reopen'], escalate: ['escalate', 'shout'],
next: ['claim', 'reserveReview', 'reserveNextReview'], run: ['claim', 'release', 'submit', 'reserveReview', 'reserveNextReview', 'verify', 'escalate', 'shout'],
init: ['register'], join: ['register'], worktree: ['register'], takeover: ['takeCoordinator'],
+ inbox: ['recordActivityDelivery', 'actOnActivity'],
shout: ['shout'], answer: ['answerDecision'], pass: ['passDecision'], fact: ['appendFact'],
hold: ['holdLane', 'releaseLane', 'holdItem', 'releaseItemHold'],
bar: ['setBarReady', 'signBar'], settings: ['setLineSetting', 'setPersonSigning'], check: ['acceptCheck'],
diff --git a/src/templates.js b/src/templates.js
index cb4a1811..9c4222bd 100644
--- a/src/templates.js
+++ b/src/templates.js
@@ -152,6 +152,8 @@ For spare test capacity, use \`pullboard runner add <ssh-host> --slots <n> --bro
If your item needs code another lane owns and it is not there yet, shout that lane and take another item. Never copy their code into your lane, and never build another lane's item, even one that was rejected and blocks you: shout that lane and the coordinator. A claim refused as BLOCKED names the item it waits on.
+The activity feed separates interrupts from digest summaries. Read \`pullboard inbox\` at your next check; rejected work, lapsing claims, answers and changed working files remain pending until you act. After acting, use \`pullboard inbox --acted-on <interrupt-ids>\` with its comma-separated ids. The board records delivery separately from acknowledgement; a local cursor never means acted-on. A short digest arrives on your first inbox check in a session and after a successful submit, without raw activity bodies. \`pullboard resume\` remains read-only.
+
**Talk.** \`pullboard shout <lane|agent|all> "<text>"\`. Only the coordinator or person marks release or focus news with \`pullboard shout all "<release or focus news>" --news\`; it arrives as a one-line digest at session start. Keep governing instructions as ordinary shouts so they stay direct. Read \`pullboard inbox\` before you start and after you submit. Only the coordinator (the agent in the main checkout) talks with the person. Every other agent sends anything that needs the person—a decision, an approval, a waiver, a preview or a phone check—to the coordinator with \`pullboard shout coordinator "<what is needed>" --decision\`, and never asks the person in its own session, even when the person is watching. An MCP client can do the same as your agent: add \`pullboard mcp\`, run from your worktree, as a stdio server; it reads the board, shows an item, shouts and captures ideas for the coordinator, and never makes a person's move.
**Listen.** Where your client can run a command in the background, run \`pullboard watch --to <your id>\` there: it prints one line per event as it happens, and Claude Code wakes on each line when it runs under the Monitor tool. \`pullboard watch --work <lane>\` also says when an item in your lane becomes claimable, a review has waited too long, or main moves. Where your client cannot, read \`pullboard inbox\` at session start, after submit and before ending a turn. Coordinator answers and sentinel findings arrive there either way.
diff --git a/test/activity-feed.test.js b/test/activity-feed.test.js
index 7cbd3885..9de7a753 100644
--- a/test/activity-feed.test.js
+++ b/test/activity-feed.test.js
@@ -284,8 +284,8 @@ test('inbox delivery uses real Git paths and board-bound cursors without consumi
const feed = JSON.parse(one.out);
assert.ok(feed.shouts.some(shout => shout.shout_text === 'A governing instruction stays direct.'));
assert.equal(feed.shouts.some(shout => shout.shout_id === firstNews), false);
- assert.ok(feed.activity.entries.some(entry => entry.kind === 'fact' && entry.item === id));
- assert.deepEqual(feed.activity.entries.find(entry => entry.kind === 'main-moved')?.files, [rowFile],
+ assert.ok(feed.activity.digests.some(entry => entry.kind === 'fact' && entry.count > 0), 'routine facts become a counted break-time summary');
+ assert.deepEqual(feed.activity.interrupts.find(entry => entry.kind === 'main-moved')?.files, [rowFile],
'the real CLI compares the exact recorded Git base and tip against the active file plan');
assert.deepEqual(feed.activity.digests.find(digest => digest.kind === 'news')?.shouts, [firstNews]);
const continued = box.run(box.web, 'inbox', '--json');
@@ -371,6 +371,9 @@ test('old ordinary shout replay does not become newly typed news [H16,N26]', (t)
test('interrupts arrive at once and the digest arrives as a short summary at a break [R2,N26,H16]', t => {
const box = e2e.project('true');
+ const foreignRoot = join(box.dir, 'interrupt-other');
+ box.git(box.repo, 'worktree', 'add', '-q', '--detach', foreignRoot, 'main');
+ assert.equal(box.run(foreignRoot, 'join', 'api', '--json').code, 0);
const base = box.git(box.web, 'rev-parse', 'HEAD');
assert.equal(e2e.commitFile(box, box.web, 'web/interrupt.txt', 'private interrupt fixture\n', 'feat(web): interrupt fixture [G1]').status, 0);
const commit = box.git(box.web, 'rev-parse', 'HEAD');
@@ -387,7 +390,7 @@ test('interrupts arrive at once and the digest arrives as a short summary at a b
review: { commit, head: commit, trunk: base, paths: ['web/interrupt.txt'] } });
const active = store.addItem(board, { by: 'coordinator', lane: 'web', title: 'Private lapsing work',
brief: 'Files: web/interrupt.txt\nTest: preserve the private fixture\n' });
- store.claim(board, active, { agentId: 'web-1', lane: 'web', leaseMs: 60_000, head: base, freeze });
+ store.claim(board, active, { agentId: 'web-1', lane: 'web', leaseMs: 4 * 60_000, head: base, freeze });
const question = store.shout(board, { from: 'web-1', to: 'coordinator', text: 'Which private path?', decision: true, lanes: ['web', 'api'] });
store.answerDecision(board, question, { agentId: 'coordinator', text: 'Use the private reviewed path.', lanes: ['web', 'api'] });
// A synthetic landing receipt exercises real Git overlap; it is not a claim of a live landing proof.
@@ -397,6 +400,7 @@ test('interrupts arrive at once and the digest arrives as a short summary at a b
store.finishLandingBatch(board, { agentId: 'coordinator', id: 'interrupt-private-main', tip: commit });
const other = store.addItem(board, { by: 'coordinator', lane: 'web', title: 'Private digest work' });
store.appendFact(board, other, { agentId: 'coordinator', kind: 'note', text: 'PRIVATE_RAW_STATUS_MUST_NOT_BE_DIGEST_TEXT' });
+ const claimBefore = store.getItem(board, active);
const first = box.run(box.web, 'inbox', '--json');
assert.equal(first.code, 0, first.err);
const feed = JSON.parse(first.out).activity;
@@ -409,6 +413,34 @@ test('interrupts arrive at once and the digest arrives as a short summary at a b
const delivered = store.events(board).filter(event => event.event_kind === 'activity-delivered');
assert.ok(delivered.length, 'delivery is recorded on the canonical board, not just a checkout cursor');
assert.ok(delivered.every(event => event.event_by === 'web-1'), 'the recipient owns its delivery receipts');
+ assert.deepEqual(store.getItem(board, active), claimBefore, 'delivery grants no claim or lease authority');
+ const again = box.run(box.web, 'inbox', '--json');
+ assert.equal(again.code, 0, again.err);
+ assert.deepEqual(new Set(JSON.parse(again.out).activity.interrupts.map(entry => entry.id)), new Set(feed.interrupts.map(entry => entry.id)),
+ 'reading or advancing a checkout cursor never means acted-on');
+ assert.deepEqual(JSON.parse(again.out).activity.digests, [], 'ordinary checks do not deliver the digest');
+ const ids = feed.interrupts.map(entry => entry.id).join(',');
+ const beforeForeign = exportBoard(board);
+ const foreign = box.run(foreignRoot, 'inbox', '--acted-on', ids, '--json');
+ assert.equal(JSON.parse(foreign.out).error?.code, 'ACTIVITY_NOT_DELIVERED');
+ assert.deepEqual(exportBoard(board), beforeForeign, 'another recipient cannot acknowledge these obligations');
+ const acted = box.run(box.web, 'inbox', '--acted-on', ids, '--json');
+ assert.equal(acted.code, 0, acted.err);
+ assert.deepEqual(JSON.parse(acted.out).activity.interrupts, []);
+ const actedEvents = store.events(board).filter(event => event.event_kind === 'activity-acted');
+ assert.equal(actedEvents.length, 1);
+ assert.deepEqual(new Set(JSON.parse(actedEvents[0].event_detail).interrupts), new Set(feed.interrupts.map(entry => entry.id)));
+ store.appendFact(board, other, { agentId: 'coordinator', kind: 'note', text: 'SECOND_PRIVATE_RAW_STATUS_BODY' });
+ const beforeBreak = box.run(box.web, 'inbox', '--json');
+ assert.equal(beforeBreak.code, 0, beforeBreak.err);
+ assert.deepEqual(JSON.parse(beforeBreak.out).activity.digests, [], 'new digest activity waits for a natural break');
+ assert.equal(e2e.commitFile(box, box.web, 'web/after-break.txt', 'private submit break\n', 'feat(web): submit break [G1]').status, 0);
+ const submitted = box.run(box.web, 'submit', String(active), '--json');
+ assert.equal(submitted.code, 0, submitted.err || submitted.out);
+ const summary = JSON.parse(submitted.out).activity;
+ assert.ok(summary.digests.length, 'the actual successful submit delivers the pending short digest');
+ assert.equal(JSON.stringify(summary.digests).includes('SECOND_PRIVATE_RAW_STATUS_BODY'), false);
+
});