Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(console): keep the swarm ADR digest true to the active mission; verify's confirm names its git reads; real-pane ADRs test (ADR-480)

ruvb62b7d334ce1
diff --git a/plugins/ruflo-console/hooks/adr-mission.ts b/plugins/ruflo-console/hooks/adr-mission.ts
index 61e3ff4684..94963c30a1 100644
--- a/plugins/ruflo-console/hooks/adr-mission.ts
+++ b/plugins/ruflo-console/hooks/adr-mission.ts
@@ -9,6 +9,7 @@ import type { ActionSpec } from './actions'
import type { AdrDoc } from './data/adr'
import { checkScope, digestBlock, reportLines, suggest, type Suggestion } from './data/adr-scope'
import { draftFromMission } from './data/adr-write'
+import { loadAdrs } from './adr'
import { plain } from './data/parse'
import type { Host } from './host'
import { activeMission, record, saveLedger } from './mission-control'
@@ -65,6 +66,44 @@ export async function mirrorDigest(state: State, host: Pick<Host, 'fs' | 'run'>)
return replaceFile(host, state.cwd, `${root(state)}/${DIGEST_FILE}`, body)
}
+const mirrored = new WeakMap<State, string>()
+
+/**
+ * Keeps the swarm's digest file true to the ACTIVE mission, called from the controller's tick and cheap when nothing moved: it writes only
+ * when the active mission or the text of its digest changed, writes an empty digest (which the swarm treats as none) when nothing is
+ * attached, and clears a file an earlier session left behind. It never creates a file in a project that has never attached an ADR, and it
+ * does not judge before the folder has been read (an unread registry would look like "nothing attached").
+ */
+export async function syncAdrDigest(state: State, host: Host): Promise<void> {
+ const mission = activeMission(state)
+ const attached = mission === null ? [] : attachedOf(mission)
+ const adr = adrOf(state)
+
+ if (attached.length > 0 && !adr.isLoaded) {
+ if (!adr.isLoading) void loadAdrs(state, host)
+
+ return
+ }
+
+ const block = mission === null ? '' : digestBlock(attachedDocs(state, mission))
+ const key = `${mission?.id ?? ''}|${block}`
+ const before = mirrored.get(state)
+
+ if (before === key) return
+
+ mirrored.set(state, key)
+
+ // The first look of a session at an empty digest only matters if an earlier session left a non-empty file.
+ if (before === undefined && block === '') {
+ const stat = await host.fs.stat(`${root(state)}/${DIGEST_FILE}`).catch(() => undefined)
+
+ if (stat === undefined) return
+ }
+
+ // A failed write is tried again on the next tick.
+ if ((await mirrorDigest(state, host)) !== null) mirrored.delete(state)
+}
+
/** Files changed in the project: uncommitted work, and commits since the mission began. Read-only git. */
export async function changedFiles(host: Pick<Host, 'run'>, cwd: string, sinceMs: number): Promise<string[]> {
const out = new Set<string>()
diff --git a/plugins/ruflo-console/hooks/controller.ts b/plugins/ruflo-console/hooks/controller.ts
index 1729fef545..0826f33097 100644
--- a/plugins/ruflo-console/hooks/controller.ts
+++ b/plugins/ruflo-console/hooks/controller.ts
@@ -32,6 +32,7 @@ import { picturesOf } from './views/frames'
import { pulseDue } from './pulse'
import { refreshWorkflows } from './wf-live'
import { syncWhatsNew } from './whatsnew'
+import { syncAdrDigest } from './adr-mission'
const ACTIVITY_BUCKET_MS = 5_000
const PANE_WATCH_MS = 1_000
@@ -131,6 +132,7 @@ export function createController(state: State, host: Host): Controller {
state.snapshot = snapshot
syncWhatsNew(state, host)
+ void syncAdrDigest(state, host).catch(() => undefined)
record(state.events, diffEvents(previous, snapshot, now))
// A mission that finished or lost a task is said in a toast too: the band's notice row reaches only a person looking at the console.
diff --git a/plugins/ruflo-console/hooks/mission-claude.ts b/plugins/ruflo-console/hooks/mission-claude.ts
index d4b1812630..e50b4d7cd2 100644
--- a/plugins/ruflo-console/hooks/mission-claude.ts
+++ b/plugins/ruflo-console/hooks/mission-claude.ts
@@ -132,7 +132,7 @@ export function claudeActions(state: State, host: Host, runner: Runner): Pick<Mi
args: [],
shows: gates.map(gate => gate.argv.join(' ')).join(' · '),
expect: 'each gate’s exit code and a short output summary recorded as evidence on the mission',
- note: 'Runs the commands you configured, one after another, without a shell, in this project. Their output is evidence; nothing is changed by the console.',
+ note: 'Runs the commands you configured, one after another, without a shell, in this project. Their output is evidence; nothing is changed by the console. With ADRs attached to the mission it then compares the changed files (git status and git log, read-only) with the paths those ADRs name, as a warning in the record.',
run: async () => {
let failed = 0
diff --git a/plugins/ruflo-console/hooks/views/adr.ts b/plugins/ruflo-console/hooks/views/adr.ts
index 9a77fbbd5c..f937a3b9b8 100644
--- a/plugins/ruflo-console/hooks/views/adr.ts
+++ b/plugins/ruflo-console/hooks/views/adr.ts
@@ -10,7 +10,7 @@ import type { RenderElement } from 'claude-code'
import { adrOf, docOf, transitionsOf } from '../adr'
import { attachedOf, suggestFor } from '../adr-mission'
import { countsOf, filterDocs, graphOf, STATUSES, type AdrDoc, type AdrStatus } from '../data/adr'
-import { activeMission, mcOf } from '../mission-control'
+import { activeMission, mcOf, progressOf } from '../mission-control'
import { button, col, kv, row, rule, section, text, THEME, type Ctx } from './common'
const PAGE = 14
@@ -88,7 +88,7 @@ function missionRows(ctx: Ctx): RenderElement[] {
const adr = adrOf(ctx.state)
const mission = activeMission(ctx.state)
- if (mission === null) return [para(ctx, ' No active mission. In Missions, create one: its ADRs are attached here, and Claude and the swarm are told the accepted decisions.', { dimColor: true })]
+ if (mission === null) return [para(ctx, ' No active mission. In Missions, create one: its ADRs are attached here, and Claude and the swarm are told the accepted decisions. The check of changed files compares paths only and does not prove a change follows a decision.', { dimColor: true })]
const attached = attachedOf(mission).map(file => docOf(ctx.state, file) ?? null)
const suggestions = suggestFor(ctx.state, mission, mission.objective)
@@ -106,6 +106,9 @@ function missionRows(ctx: Ctx): RenderElement[] {
for (const suggestion of suggestions) rows.push(row(ctx, [button(ctx, `adr-sug-${suggestion.doc.file}`, `+ ADR ${suggestion.doc.number ?? suggestion.doc.file}`, () => ctx.act.adrs.attach(suggestion.doc.file, true)), text(ctx, ` ${suggestion.doc.title.slice(0, 40)} · ${suggestion.why}`.slice(0, Math.max(10, ctx.columns - 22)), { dimColor: true })], `adr-sugrow-${suggestion.doc.file}`))
}
+ const progress = progressOf(mission, ctx.state.snapshot?.tasks ?? [])
+
+ if (progress.total > 0 && progress.done >= progress.total) rows.push(text(ctx, ' this mission is finished: if it decided something worth keeping, draft an ADR below (a person writes the decision)', { color: THEME.ok }))
rows.push(row(ctx, [button(ctx, 'adr-scope', 'â–¸ check changed files against the attached ADRs', () => ctx.act.adrs.scope()), button(ctx, 'adr-draft', 'â–¸ draft an ADR from this mission', () => ctx.act.adrs.draft())], 'adr-mission-actions'))
if (adr.scope !== null) rows.push(...adr.scope.hits.slice(0, 6).map(hit => text(ctx, ` ! ${hit.file} is in the scope of ADR ${hit.adr.number ?? hit.adr.file} (${hit.entry})`, { color: THEME.warn })))
diff --git a/plugins/ruflo-console/tests/adr-integration.spec.ts b/plugins/ruflo-console/tests/adr-integration.spec.ts
index ac90066a63..3cddc5a41b 100644
--- a/plugins/ruflo-console/tests/adr-integration.spec.ts
+++ b/plugins/ruflo-console/tests/adr-integration.spec.ts
@@ -11,7 +11,7 @@ import { join } from 'node:path'
import { afterAll, describe, expect, it } from 'vitest'
import { adrOf, loadAdrs } from '../hooks/adr'
-import { adrBlockFor, attachedOf, DIGEST_FILE, draftSpec, mirrorDigest, scopeCheck, setAttached, suggestFor } from '../hooks/adr-mission'
+import { adrBlockFor, attachedOf, DIGEST_FILE, draftSpec, mirrorDigest, scopeCheck, setAttached, suggestFor, syncAdrDigest } from '../hooks/adr-mission'
import { contextSection, claudeActions } from '../hooks/mission-claude'
import { missionContextText } from '../hooks/mission-context'
import { instructionOf, loadLedger, LEDGER_KEY, mcOf } from '../hooks/mission-control'
@@ -154,6 +154,65 @@ describe('the digest reaches Claude, the task instruction and the swarm', () =>
expect(await mirrorDigest(state, host as never)).toBeNull()
})
+ it('the digest follows the ACTIVE mission: a switch rewrites it, a mission with nothing attached clears it, and a project that never attached gets no file', async () => {
+ const { state, host, root, log } = await world('nygard')
+ const file = join(root, DIGEST_FILE)
+ const mine = state
+
+ await syncAdrDigest(mine, host as never)
+ expect(existsSync(file), 'nothing attached, nothing written').toBe(false)
+
+ await setAttached(mine, host as never, '0003-use-graphql.md', true)
+ expect(JSON.parse(readFileSync(file, 'utf8')).block).toContain('GraphQL')
+
+ // Switch to a second mission with nothing attached: the first one's decisions must not reach its subagents.
+ const other = missionOf({ id: 'msn_bbbbbbbbbbbbbbbbbbbbbbbb', objective: 'Something else' })
+
+ mcOf(mine).missions.set(other.id, other)
+ mcOf(mine).active = other.id
+ await syncAdrDigest(mine, host as never)
+
+ const cleared = JSON.parse(readFileSync(file, 'utf8')) as { block: string; mission: string }
+
+ expect(cleared).toMatchObject({ block: '', mission: 'msn_bbbbbbbbbbbbbbbbbbbbbbbb' })
+
+ // And back again.
+ mcOf(mine).active = 'msn_aaaaaaaaaaaaaaaaaaaaaaaa'
+ await syncAdrDigest(mine, host as never)
+ expect(JSON.parse(readFileSync(file, 'utf8')).block).toContain('GraphQL')
+
+ // An unchanged state writes nothing more.
+ const writes = log.runs.length
+
+ await syncAdrDigest(mine, host as never)
+ await syncAdrDigest(mine, host as never)
+ expect(log.runs.length).toBe(writes)
+ })
+
+ it('a file left by an earlier session is cleared at the first look; an unread registry is not mistaken for "nothing attached"', async () => {
+ const { state, host, root, mission } = await world('nygard')
+ const file = join(root, DIGEST_FILE)
+
+ mkdirSync(join(root, '.claude-flow/console'), { recursive: true })
+ writeFileSync(file, JSON.stringify({ v: 1, atMs: Date.now(), mission: 'old', adrs: [], block: 'STALE decisions' }))
+ await syncAdrDigest(state, host as never)
+ expect(JSON.parse(readFileSync(file, 'utf8')).block).toBe('')
+
+ // A new session: the mission has an attachment but the folder is not read yet. The file is left alone until it is.
+ ;(mission as MissionRecord).adrs = ['0003-use-graphql.md']
+
+ const fresh = await world('nygard')
+ const m = fresh.mission as MissionRecord
+
+ m.adrs = ['0003-use-graphql.md']
+ writeFileSync(join(fresh.root, 'keep.txt'), 'x')
+ mkdirSync(join(fresh.root, '.claude-flow/console'), { recursive: true })
+ writeFileSync(join(fresh.root, DIGEST_FILE), JSON.stringify({ v: 1, atMs: Date.now(), mission: m.id, adrs: [], block: 'KEEP until read' }))
+ adrOf(fresh.state).isLoaded = false
+ await syncAdrDigest(fresh.state, fresh.host as never)
+ expect(JSON.parse(readFileSync(join(fresh.root, DIGEST_FILE), 'utf8')).block).toBe('KEEP until read')
+ })
+
it('the swarm ignores a digest that is oversize, malformed or from a hostile writer', async () => {
const files: Record<string, string> = {}
const fs = { read: async (path: string) => files[path] ?? Promise.reject(new Error('x')), stat: async (path: string) => (files[path] === undefined ? undefined : { size: files[path]?.length }) }
diff --git a/plugins/ruflo-console/tests/adrs.test.ts b/plugins/ruflo-console/tests/adrs.test.ts
new file mode 100644
index 0000000000..a0b7365d05
--- /dev/null
+++ b/plugins/ruflo-console/tests/adrs.test.ts
@@ -0,0 +1,97 @@
+/**
+ * The ADRs page through the real engine and pane (ADR-480): the page is reached from the nav, the menu and by name, reads the project's own
+ * ADR folder, shows the records and the health strip, a propose goes through the confirm row and writes the new file once with a toast
+ * and an Events notice, and nothing is fetched. Run with `claude plugin test` (scripts/kit-seq.sh adrs).
+ */
+import type { TestBody } from 'claude-code/testing'
+import { describe, expect, mock, test } from 'claude-code/testing'
+
+import { RUFLO_FILES } from './fixtures/ruflo-run'
+import { command, elementsOf, keyOf, paneAt, PLUGIN, SESSION, textOf as rawText, worldOf } from './fixtures/world'
+
+const textOf = (tree: Parameters<typeof rawText>[0]) => rawText(tree).toLowerCase()
+
+type Body = Parameters<TestBody>
+
+const ADRS = {
+ 'docs/adr/0001-record-architecture-decisions.md': '# 1. Record architecture decisions\n\nDate: 2026-01-02\n\n## Status\n\nAccepted\n\n## Context\n\nWe need records.\n\n## Decision\n\nWe will keep ADRs.\n',
+ 'docs/adr/0002-use-queues.md': '# 2. Use queues\n\nDate: 2026-02-03\n\n## Status\n\nProposed\n\n## Decision\n\nQueues, in `services/queue/`.\n',
+}
+
+async function start($: Body[0], on: Body[1], files: Record<string, string> = ADRS) {
+ const world = worldOf(on, { ...RUFLO_FILES, ...files })
+ const clock = mock.clock(on)
+ let fetches = 0
+
+ on('http.fetch', () => (fetches += 1, { deny: 'no network in this test' }) as never)
+ await $.session.start(SESSION)
+
+ return { world, clock, fetches: () => fetches }
+}
+
+async function mounted($: Body[0], view: string, columns = 130) {
+ await $.command.run(command(view))
+
+ const pane = await $.ui.mount({ ...paneAt(columns), surface: 'terminal' as const, plugin: PLUGIN })
+
+ await pane.drawn()
+
+ return pane
+}
+
+describe('ADRs, end to end', () => {
+ test('opens from /ruflo adrs, reads the project’s own folder and lists the records with the health strip, fetching nothing', { options: { boot: false } }, async ($, on) => {
+ const { clock, fetches } = await start($, on)
+ const pane = await mounted($, 'adrs')
+
+ await clock.advance(1_600)
+
+ const tree = await pane.drawn()
+ const text = textOf(tree)
+
+ expect(text).toContain('docs/adr')
+ expect(text).toContain('record architecture decisions')
+ expect(text).toContain('use queues')
+ expect(text).toContain('2 records · 1 accepted · 1 proposed')
+ expect(text).toContain('compares paths only')
+ expect(elementsOf(tree, 'Button').map(keyOf)).toEqual(expect.arrayContaining(['adr-row-0001-record-architecture-decisions.md', 'adr-f-accepted', 'adr-reload', 'adr-prev', 'adr-next']))
+ expect(fetches()).toBe(0)
+ await pane.unmount()
+ })
+
+ test('is reached by the TOOLS group, by search, and has no hotkey; selecting a record opens its detail', { options: { boot: false } }, async ($, on) => {
+ const { clock } = await start($, on)
+ const pane = await mounted($, 'overview')
+
+ await pane.press({ key: 'nav-group-TOOLS' })
+ expect(elementsOf(await pane.drawn(), 'Button').map(keyOf)).toContain('tab-adrs')
+ await pane.press({ key: 'tab-adrs' })
+ await clock.advance(1_600)
+ await pane.press({ key: 'adr-row-0002-use-queues.md' })
+ await clock.advance(100)
+
+ const text = textOf(await pane.drawn())
+
+ expect(text).toContain('adr 2: use queues')
+ expect(text).toContain('services/queue/')
+ expect(text).toContain('mark accepted')
+ await pane.unmount()
+ })
+
+ test('a project with no ADR folder offers to initialise it, and the folder is created only after the Yes', { options: { boot: false } }, async ($, on) => {
+ const { world, clock } = await start($, on, {})
+ const pane = await mounted($, 'adrs')
+
+ await clock.advance(1_600)
+ expect(textOf(await pane.drawn())).toContain('initialise adrs here')
+ expect([...world.files.keys()].some(path => path.includes('/docs/adr/'))).toBe(false)
+ await pane.press({ key: 'adr-init' })
+ await clock.advance(100)
+
+ const card = textOf(await pane.drawn())
+
+ expect(card).toContain('docs/adr/0001-record-architecture-decisions.md')
+ expect(world.runs.some(argv => argv.join(' ').includes('0001-record'))).toBe(false)
+ await pane.unmount()
+ })
+})
diff --git a/plugins/ruflo-console/tests/fixtures/world.ts b/plugins/ruflo-console/tests/fixtures/world.ts
index efa7f6a33c..792674c7ea 100644
--- a/plugins/ruflo-console/tests/fixtures/world.ts
+++ b/plugins/ruflo-console/tests/fixtures/world.ts
@@ -119,6 +119,9 @@ export function worldOf(on: On, files: Readonly<Record<string, string>>, options
world.stats.push(e.path)
const text = all.get(e.path)
+ // A folder that holds a file stats as a directory, as a real one does (the ADRs page asks before it lists).
+ if (!refuse && text === undefined && [...all.keys()].some(path => path.startsWith(`${e.path}/`))) return { value: { kind: 'dir' as const, size: 0, mtimeMs: 1, isLink: false } }
+
return refuse || text === undefined ? { deny: `ENOENT: ${e.path}` } : { value: { kind: 'file' as const, size: text.length, mtimeMs: mtimes.get(e.path) ?? 0, isLink: false } }
})
on('fs.list', ($, e) => {
diff --git a/plugins/ruflo-console/tests/whatsnew.test.ts b/plugins/ruflo-console/tests/whatsnew.test.ts
index a9c16a7beb..fbb1c33b5a 100644
--- a/plugins/ruflo-console/tests/whatsnew.test.ts
+++ b/plugins/ruflo-console/tests/whatsnew.test.ts
@@ -10,6 +10,7 @@ import { describe, expect, mock, test } from 'claude-code/testing'
import { RUFLO_FILES } from './fixtures/ruflo-run'
import { command, elementsOf, keyOf, paneAt, PLUGIN, SESSION, textOf as rawText, worldOf } from './fixtures/world'
+import { CONSOLE_VERSION } from '../hooks/version'
/** The BBS look draws headers in capitals, so the page's words are compared in lower case. */
const textOf = (tree: Parameters<typeof rawText>[0]) => rawText(tree).toLowerCase()
@@ -37,7 +38,7 @@ async function start($: Body[0], on: Body[1], options: { swarm?: string; notes?:
})
const clock = mock.clock(on)
- if (options.seen !== null) world.stored.set('whatsnew', JSON.stringify({ v: 1, seen: options.seen ?? { 'ruflo-swarm': '0.4.0', 'ruflo-core': '0.2.6', 'ruflo-console': '0.38.0' }, toasted: options.toasted ?? { 'ruflo-swarm': '0.5.0', 'ruflo-core': '0.2.6', 'ruflo-console': '0.38.0' }, pinned: [], dismissed: [], toast: true }))
+ if (options.seen !== null) world.stored.set('whatsnew', JSON.stringify({ v: 1, seen: options.seen ?? { 'ruflo-swarm': '0.4.0', 'ruflo-core': '0.2.6', 'ruflo-console': CONSOLE_VERSION }, toasted: options.toasted ?? { 'ruflo-swarm': '0.5.0', 'ruflo-core': '0.2.6', 'ruflo-console': CONSOLE_VERSION }, pinned: [], dismissed: [], toast: true }))
let fetches = 0
@@ -114,7 +115,7 @@ describe('What’s new, end to end', () => {
})
test('one info toast when a new version is found, none for the same version again, and none when the switch is off', { options: { boot: false } }, async ($, on) => {
- const { world, clock } = await start($, on, { toasted: { 'ruflo-swarm': '0.4.0', 'ruflo-core': '0.2.6', 'ruflo-console': '0.38.0' } })
+ const { world, clock } = await start($, on, { toasted: { 'ruflo-swarm': '0.4.0', 'ruflo-core': '0.2.6', 'ruflo-console': CONSOLE_VERSION } })
const pane = await mounted($, 'overview')
diff --git a/scripts/ci-test-excluded.txt b/scripts/ci-test-excluded.txt
index f4e340ecf3..4e0464d030 100644
--- a/scripts/ci-test-excluded.txt
+++ b/scripts/ci-test-excluded.txt
@@ -81,6 +81,7 @@ tests/check-status-forwarding.test.mjs
plugins/ruflo-console/tests/result-display.test.ts
plugins/ruflo-console/tests/toasts.test.ts
plugins/ruflo-console/tests/whatsnew.test.ts
+plugins/ruflo-console/tests/adrs.test.ts
plugins/ruflo-protector/tests/corpus.test.ts
plugins/ruflo-protector/tests/mod.test.ts
plugins/ruflo-protector/tests/rules.test.ts
diff --git a/v3/docs/adr/ADR-480-adr-management.md b/v3/docs/adr/ADR-480-adr-management.md
index 20d2020141..ce32ef81fe 100644
--- a/v3/docs/adr/ADR-480-adr-management.md
+++ b/v3/docs/adr/ADR-480-adr-management.md
@@ -94,9 +94,9 @@ A health strip and the lint; a status filter, a text filter and a scope filter;
- **Attach** (page or `adr-attach <n>`): up to 8 file names on the mission record (`MissionRecord.adrs`, validated on load). **Suggest**: from the goal, a path in the goal under an ADR's scope counts most, then shared title and scope words; only proposed and accepted records are offered; the person presses to attach. Nothing is attached by itself.
- **Context for Claude**: `missionContextText` appends the digest after the mission's own lines (title, status, the start of the Decision, masked by the Events washer, 260 characters each, 1100 in all, accepted first; a proposed record is marked a draft and a superseded one as history). The text is keyed by a hash of the digest, so Claude's prompt changes only when an attached record's status or decision does. The task instruction (`instructionOf`) carries the same block. Both say the block is data, not instructions.
-- **Scope check** (the `adr-scope` entry, the page button, and automatically at the end of **verify**): `git status --porcelain` plus the commits since the mission began; each changed file is matched against the scope paths of the attached **accepted** records. A hit is a `warning` in the mission record (an `adr.scope` event, so it is evidence) and in the verify result line. It never changes whether the gates passed and never blocks: the existing gate mechanism is the person's own commands with exit codes, which has no notion of a soft finding, so the check follows the loop's other advisory outputs.
+- **Scope check** (the `adr-scope` entry, the page button, and automatically at the end of **verify**, whose confirm names the extra read-only git commands): `git status --porcelain` plus the commits since the mission began; each changed file is matched against the scope paths of the attached **accepted** records. A hit is a `warning` in the mission record (an `adr.scope` event, so it is evidence) and in the verify result line. It never changes whether the gates passed and never blocks: the existing gate mechanism is the person's own commands with exit codes, which has no notion of a soft finding, so the check follows the loop's other advisory outputs.
- **After a mission**: *draft an ADR from this mission* is a normal propose confirm, pre-filled with the goal and the task titles and results. It is deterministic. The decision itself is left as a sentence saying it is not in the record. There is no claude -p turn for this (the console's guidance turn exists for goals, not for retrospectives), so none was added.
-- **Swarm**: the console writes the digest of the active mission's attached ADRs to `.claude-flow/console/adr-digest.json` (small, masked, with a timestamp) whenever attachments or the active mission change. ruflo-swarm's `agent.spawn` hook reads it, ignores one that is missing, over 16 KB, malformed or older than a day, and appends the block after the task prompt; the member row says `[guided by ADR 3, 7]` and keeps the numbers (accepted records only). Option `injectAdrs`, on by default; nothing is added without an attached ADR.
+- **Swarm**: the console writes the digest of the active mission's attached ADRs to `.claude-flow/console/adr-digest.json` (small, masked, with a timestamp) whenever attachments change, and the controller's tick (`syncAdrDigest`) rewrites it when the **active mission** or the digest's text changes: switching to a mission with nothing attached writes an empty digest (the swarm treats it as none), and a file left by an earlier session is cleared at the first look. It never creates a file in a project that has not attached an ADR, and it does not judge before the folder has been read. ruflo-swarm's `agent.spawn` hook reads it, ignores one that is missing, over 16 KB, malformed or older than a day, and appends the block after the task prompt; the member row says `[guided by ADR 3, 7]` and keeps the numbers (accepted records only). Option `injectAdrs`, on by default; nothing is added without an attached ADR.
- **Workflows**: no extension point. The console has no engine and no step types, and ruflo's workflow definitions are outside this repository's console. The ruflo-workflows skill documents two ordinary steps instead, *requires ADR* (attach and read the governing records first) and *records ADR* (`adr-propose` last), and the mission lifecycle above carries the rest.
### 2.6 For Claude (console_run) and the control levels
@@ -121,6 +121,7 @@ Nothing here proves that code complies with an ADR. `scope` is the set of backti
- A workflow step *type* (no engine here).
- A hard block on a scope hit (the gates have no soft/hard distinction; a hard block on a path heuristic would refuse good changes).
- ruflo-adr changes (separate plugin; its parser's gap with plain `Status:` lines is recorded in 1.2 and left alone).
+ - A notice or toast when a mission finishes offering a draft (the finished mission's ADRs section says so and the button is there; the shared `mission-done` notice text is pinned by other tests and was left alone).
- Auto-attach from the goal, and auto-writing of drafts (the person decides both).
- Sequence numbers for date-prefixed names (log4brains): they are listed and flagged `no number`; a new record in such a project gets `0001-`.
- A claude -p turn to write the draft's decision (no such turn exists for retrospectives).