🌊 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
feat(mods): startup self-check toast, doctor/install addenda, spike of the engine's toast text (0.6.0)
r65398f5f83ca
diff --git a/plugins/ruflo-mods/.claude-plugin/plugin.json b/plugins/ruflo-mods/.claude-plugin/plugin.jsonindex 24a5c72c2d..ff01475681 100644--- a/plugins/ruflo-mods/.claude-plugin/plugin.json+++ b/plugins/ruflo-mods/.claude-plugin/plugin.json@@ -1,7 +1,7 @@{"name": "ruflo-mods","description": "ruflo as a Claude Code mod (function hooks, ADR-404): in-process prompt routing, edit learning signals, tighten-only tool checks from ruflo policy, the cost-tracker budget ladder, a mod trust gate for newly installed mods, and the $.ruflo noun other mods compose their status with. Opt-in and removable: the classic hook-handler hooks stay the default and take every event back whenever the mod is not loaded.",- "version": "0.5.1",+ "version": "0.6.0","author": {"name": "ruvnet","url": "https://github.com/ruvnet"@@ -142,6 +142,13 @@"description": "Record versioned rule IDs and activity counters in a separate candidate queue. Does not record task success, train or promote guidance.","required": false,"default": false+ },+ "selfCheck": {+ "type": "boolean",+ "title": "Startup self-check",+ "description": "Say once per session, in a toast, when an enabled ruflo plugin is missing from the ruflo marketplace clone (Claude Code then skips it without a word), with the one-line repair. Read-only; never adds text for the model.",+ "required": false,+ "default": true}}}diff --git a/plugins/ruflo-mods/CHANGELOG.md b/plugins/ruflo-mods/CHANGELOG.mdindex ed138f54e5..5bead50c50 100644--- a/plugins/ruflo-mods/CHANGELOG.md+++ b/plugins/ruflo-mods/CHANGELOG.md@@ -2,6 +2,10 @@Newest first. One `## <version> — <date>` heading per version, then `feat:`, `fix:`, `breaking:` and `chore:` bullets (ADR-478). Built from git history; older versions: `git log -- plugins/ruflo-mods`.+## 0.6.0 — 2026-10-11+- feat: option `selfCheck` (default on): once per session, a toast when an enabled ruflo plugin (ruflo-console, ruflo-swarm) is missing from the ruflo marketplace clone and has no cached install, which makes Claude Code skip it without a word. The line is fixed text with the repair (`claude plugin marketplace update ruflo`); read-only, fail-open, nothing for the model.+- chore: smoke checks that `/ruflo-mods` stays an alias of `/ruflo mods` (ADR-406) and that the self-check cannot write or echo repository text.+## 0.5.1 — 2026-10-10- fix: the attention row says STALE when the console's summary is older than 15 minutes (three missed 5-minute heartbeats) or carries no believable time, so a closed console or a turned-off session workspace no longer shows its last counts as current (#3981)diff --git a/plugins/ruflo-mods/README.md b/plugins/ruflo-mods/README.mdindex 0b2057c3e1..8aeaea60a4 100644--- a/plugins/ruflo-mods/README.md+++ b/plugins/ruflo-mods/README.md@@ -94,6 +94,7 @@ Claude Code reads a plugin's options from `pluginConfigs["ruflo-mods@ruflo"].opt| `capabilityProbe` | `false` | Observability only (ADR-451 item 5): `/ruflo-mods` gains `probe: engine <version> · events fired n/m · never fired: ...`; reads no payload and never denies, rewrites or delays. Live run: [ruflo-mods-options-live-2026-10.md](../../v3/docs/validation/ruflo-mods-options-live-2026-10.md); design in [ADR-451](../../v3/docs/adr/ADR-451-mod-capability-roadmap.md) || `sessionRollup` | `false` | Observability only (ADR-451 item 6): at session end one counter record (no prompt text, inputs or paths) goes to a user-global ledger capped at 50 sessions and 32 KB; `/ruflo-mods` shows the last few. Live run: [ruflo-mods-options-live-2026-10.md](../../v3/docs/validation/ruflo-mods-options-live-2026-10.md); design in [ADR-451](../../v3/docs/adr/ADR-451-mod-capability-roadmap.md) || `sessionAttention` | `false` | Observability only (ADR-486): one `attention:` row in `/ruflo-mods` with ruflo-console's four counts (to approve, questions, failed, finished unread), read from `.claude-flow/console/attention.json`. Counts only; nothing gates, denies or delays. |+| `selfCheck` | `true` | Startup self-check (ADR-404 addendum): once per session, a toast when a ruflo plugin your settings enable is missing from the ruflo marketplace clone with no cached install (Claude Code then skips it without a word), with the one-line repair. Read-only; fixed text; never adds anything for the model. || `grounding` | `false` | Status only (ADR-487): `/ruflo-mods` gains `grounding: RuvNet Brain: on / not installed / installed, disabled / unknown`, read from `installed_plugins.json` and your settings. It detects Stuart Kerr's optional third-party [ruvnet-brain](https://github.com/stuinfla/ruvnet-brain) plugin by name only; it never calls, installs, blocks or rewrites anything, and ruflo works the same without it || `modTrust` | `observe` | `observe` / `refuse-risky` / `off`: the mod trust gate. Evidence: [capability review](../../v3/docs/validation/mod-capability-review-2026-10.md) || `modTrustAllow` | empty | Comma-separated plugin ids (`name@marketplace`, e.g. `ruflo-swarm@ruflo,ruflo-console@ruflo`) the gate never refuses. Evidence: [capability review](../../v3/docs/validation/mod-capability-review-2026-10.md) |diff --git a/plugins/ruflo-mods/hooks/options.ts b/plugins/ruflo-mods/hooks/options.tsindex aad6d82c56..17c06a3294 100644--- a/plugins/ruflo-mods/hooks/options.ts+++ b/plugins/ruflo-mods/hooks/options.ts@@ -19,6 +19,7 @@ export type ModOptions = {readonly capabilityProbe: booleanreadonly sessionRollup: booleanreadonly sessionAttention: boolean+ readonly selfCheck: booleanreadonly grounding: booleanreadonly modTrust: TrustPolicyreadonly modTrustAllow: ReadonlySet<string>@@ -52,6 +53,7 @@ export function readOptions(options: PluginOptions | undefined): ModOptions {capabilityProbe: bool(o.capabilityProbe, false),sessionRollup: bool(o.sessionRollup, false),sessionAttention: bool(o.sessionAttention, false),+ selfCheck: bool(o.selfCheck, true),grounding: bool(o.grounding, false),modTrust: TRUST.includes(o.modTrust as TrustPolicy) ? (o.modTrust as TrustPolicy) : 'observe',modTrustAllow: names(o.modTrustAllow),diff --git a/plugins/ruflo-mods/hooks/selfcheck.ts b/plugins/ruflo-mods/hooks/selfcheck.tsnew file mode 100644index 0000000000..1f37af9e38--- /dev/null+++ b/plugins/ruflo-mods/hooks/selfcheck.ts@@ -0,0 +1,91 @@+import type { ModState } from './state'++/**+ * Startup self-check: when a ruflo plugin the settings enable is not in the ruflo marketplace clone and has no cached install, Claude Code+ * skips it without a word (`/ruflo` or `/ruflo-mods` is then an unknown command). This says so once, in a toast, with the repair.+ *+ * Fail-open and read-only: every read is guarded, nothing is written, and the toast names only fixed plugin names and a fixed command, so+ * nothing from the repository or a settings file can reach the line. It never produces model-facing text.+ */+const SIBLINGS = ['ruflo-console', 'ruflo-swarm'] as const+const MARKETPLACE = 'ruflo'+const SOURCE = /^[A-Za-z0-9._/@-]{1,200}$/++/** What the check reads, as functions (the engine's `$` is followed only inside the file that spells it: session.ts hands these in). */+export type SelfCheckIo = {+ read: (path: string) => Promise<string>+ exists: (path: string) => Promise<boolean>+ home: () => Promise<string | undefined>+ configDirEnv: () => Promise<string | undefined>+}++const record = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v)++async function readJson(io: SelfCheckIo, path: string): Promise<unknown> {+ try {+ return JSON.parse(await io.read(path))+ } catch {+ return undefined+ }+}++/** The enabled ruflo plugins this check watches: the mod's siblings that settings turn on (`false` is a decision, not a fault). */+export function watched(enabledPlugins: unknown): string[] {+ if (!record(enabledPlugins)) return []++ return SIBLINGS.filter(name => enabledPlugins[`${name}@${MARKETPLACE}`] === true)+}++/** The one line the person sees. Fixed words only: the plugin names come from this file, never from a file read. */+export function selfCheckLine(missing: readonly string[]): string {+ return `ruflo marketplace clone is stale: ${missing.join(', ')} not loaded. Run: claude plugin marketplace update ${MARKETPLACE}`+}++async function missingFromClone(io: SelfCheckIo, configDir: string, names: readonly string[]): Promise<string[]> {+ const known = await readJson(io, `${configDir}/plugins/known_marketplaces.json`)+ const entry = record(known) ? known[MARKETPLACE] : undefined+ const declared = record(entry) && typeof entry.installLocation === 'string' && SOURCE.test(entry.installLocation) ? entry.installLocation : undefined+ const clone = declared ?? `${configDir}/plugins/marketplaces/${MARKETPLACE}`++ // No clone at all: Claude Code clones it at the next interactive start; nothing is "stale" yet.+ if (!(await io.exists(clone).catch(() => false))) return []++ const catalog = await readJson(io, `${clone}/.claude-plugin/marketplace.json`)+ const listed = record(catalog) && Array.isArray(catalog.plugins) ? catalog.plugins : []+ const installed = await readJson(io, `${configDir}/plugins/installed_plugins.json`)+ const plugins = record(installed) && record(installed.plugins) ? installed.plugins : {}+ const out: string[] = []++ for (const name of names) {+ const hit = listed.find((p): p is Record<string, unknown> => record(p) && p.name === name)+ const source = typeof hit?.source === 'string' && SOURCE.test(hit.source) && !hit.source.includes('..') ? hit.source : `./plugins/${name}`+ const inClone = await io.exists(`${clone}/${source}/.claude-plugin/plugin.json`).catch(() => false)+ const cached = (Array.isArray(plugins[`${name}@${MARKETPLACE}`]) ? (plugins[`${name}@${MARKETPLACE}`] as unknown[]) : []).some(+ e => record(e) && typeof e.installPath === 'string' && e.scope === 'user' && SOURCE.test(e.installPath),+ )+ const cachedHere = cached ? await Promise.all((plugins[`${name}@${MARKETPLACE}`] as Array<Record<string, unknown>>).filter(e => e.scope === 'user').map(e => io.exists(String(e.installPath)).catch(() => false))) : []++ if (!inClone && !cachedHere.some(Boolean)) out.push(name)+ }++ return out+}++export async function runSelfCheck(io: SelfCheckIo, state: ModState, enabledPlugins: unknown): Promise<void> {+ try {+ const names = watched(enabledPlugins)++ if (names.length === 0) return++ const home = await io.home().catch(() => undefined)+ const configDir = (await io.configDirEnv().catch(() => undefined)) ?? (home === undefined || home === '' ? undefined : `${home}/.claude`)++ if (configDir === undefined || !SOURCE.test(configDir)) return++ const missing = await missingFromClone(io, configDir, names)++ if (missing.length > 0) await state.say({ level: 'warn', text: selfCheckLine(missing), timeoutMs: 12_000, always: true })+ } catch {+ // a self-check never fails a session+ }+}diff --git a/plugins/ruflo-mods/hooks/session.ts b/plugins/ruflo-mods/hooks/session.tsindex 9d7490ed22..a7a84d5f09 100644--- a/plugins/ruflo-mods/hooks/session.ts+++ b/plugins/ruflo-mods/hooks/session.ts@@ -8,6 +8,7 @@ import type { ModOptions } from './options'import { ATTENTION_MAX_BYTES, ATTENTION_STATUS, attentionLine } from './attention'import { MAX_BYTES, PROTECTOR_STATUS, protectorLine } from './protector'import { redraw, report, under, type ModState } from './state'+import { runSelfCheck } from './selfcheck'import { bindToasts } from './toast'/** `/ruflo-mods` plus the protector row when `.claude-flow/protector-mod/status.json` is present and readable (bounded, regular file only). */@@ -110,6 +111,7 @@ export function registerSession(on: On, state: ModState, options: ModOptions, gu// neither own project events nor be created by the display heartbeat.const project = await $.fs.stat(under(state, '.claude-flow')).then(stat => stat.kind === 'dir').catch(() => false)const settings = await $.settings.read()+ if (options.selfCheck) await runSelfCheck({ read: path => $.fs.read(path), exists: path => $.fs.exists(path), home: () => $.env.get('HOME'), configDirEnv: () => $.env.get('CLAUDE_CONFIG_DIR') }, state, (settings as { enabledPlugins?: unknown } | null)?.enabledPlugins)state.owned = new Set(project ? ownedEvents(settings, await helperHonours($)) : [])await $.env.set('RUFLO_MODS_OWNS', state.owned.size ? [...state.owned].join(',') : undefined)state.statusLine = options.statusLine && !hasClassicStatusLine(settings)diff --git a/plugins/ruflo-mods/scripts/smoke.sh b/plugins/ruflo-mods/scripts/smoke.shindex 57014149da..8a78e37cbf 100755--- a/plugins/ruflo-mods/scripts/smoke.sh+++ b/plugins/ruflo-mods/scripts/smoke.sh@@ -1,5 +1,5 @@#!/usr/bin/env bash-# Structural + security smoke for ruflo-mods v0.5.1 (ADR-404, ADR-447).+# Structural + security smoke for ruflo-mods v0.6.0 (ADR-404, ADR-447).# Static only: CI has no Claude Code, so the hooks module's behaviour is held# by v3/@claude-flow/cli/__tests__/mods/*.test.ts and, where function hooks are# on, by `claude plugin test plugins/ruflo-mods`.@@ -12,9 +12,9 @@ ok() { printf "PASS\n"; PASS=$((PASS+1)); }bad() { printf "FAIL: %s\n" "$1"; FAIL=$((FAIL+1)); }HOOKS="$ROOT/hooks"-step "1. plugin.json declares ruflo-mods 0.5.1"+step "1. plugin.json declares ruflo-mods 0.6.0"grep -q '"name": "ruflo-mods"' "$ROOT/.claude-plugin/plugin.json" \- && grep -q '"version": "0.5.1"' "$ROOT/.claude-plugin/plugin.json" && ok || bad "name/version"+ && grep -q '"version": "0.6.0"' "$ROOT/.claude-plugin/plugin.json" && ok || bad "name/version"step "2. hooks.json names exactly one module and no classic hook commands"grep -q '"modules": \["./register.ts"\]' "$HOOKS/hooks.json" && ! grep -q '"command"' "$HOOKS/hooks.json" \@@ -85,5 +85,15 @@ hits=$(grep -nE "\\bon\\(|decision|deny|\\\$\\.|\\.write|spawn|tool\\.call|submiids=$(grep -rnE "mcp__plugin_ruvnet|plugin_ruvnet-brain|search_ruvnet" "$HOOKS" || true)[[ -z "$hits" && -z "$ids" ]] && ok || bad "grounding.ts must only read and report: $hits $ids"+step "16. the /ruflo-mods command stays an alias of /ruflo mods (ADR-406): the mod registers it and the console delegates mods to the mod"+CONSOLE="$ROOT/../ruflo-console/hooks"+if [[ -d "$CONSOLE" ]]; then+ grep -q "name: 'ruflo-mods'" "$HOOKS/session.ts" && grep -q "owner: 'ruflo-mods'" "$CONSOLE/commands.ts" && ok || bad "alias registration or console delegation missing"+else printf "SKIP (no sibling ruflo-console)\n"; fi++step "17. the startup self-check is read-only and fixed-text: no write, no env set, no engine handle, no repository text in the line (ADR-404 addendum)"+hits=$(grep -nE "\\.write|env\\.set|\\\$\\.|tool\\.call|spawn" "$HOOKS/selfcheck.ts" | grep -vE '^[0-9]+:\s*(\*|//|/\*)' || true)+[[ -z "$hits" ]] && grep -q "export function selfCheckLine" "$HOOKS/selfcheck.ts" && ok || bad "selfcheck.ts must only read and speak a fixed line: $hits"+printf "\n%d passed, %d failed\n" "$PASS" "$FAIL"[[ $FAIL -eq 0 ]]diff --git a/plugins/ruflo-mods/tests/selfcheck.test.ts b/plugins/ruflo-mods/tests/selfcheck.test.tsnew file mode 100644index 0000000000..f27a94f799--- /dev/null+++ b/plugins/ruflo-mods/tests/selfcheck.test.ts@@ -0,0 +1,104 @@+import type { On } from 'claude-code'+import { describe, expect, test, tier } from 'claude-code/testing'++import { START, world } from './fixtures/world'++tier('user')++const HOME = '/home/p'+const CFG = `${HOME}/.claude`+const CLONE = `${CFG}/plugins/marketplaces/ruflo`+const manifest = (name: string) => `${CLONE}/plugins/${name}/.claude-plugin/plugin.json`+const ALL = { 'ruflo-mods@ruflo': true, 'ruflo-swarm@ruflo': true, 'ruflo-console@ruflo': true }+const known = JSON.stringify({ ruflo: { source: { source: 'github', repo: 'ruvnet/ruflo' }, installLocation: CLONE } })++/** The world with a home, the settings, and what the toast hook saw (the self-check speaks through the shared toast policy). */+function rig(on: On, enabled: Record<string, unknown>, files: Record<string, string> = {}) {+ const w = world(on, { enabledPlugins: enabled }, files)+ const toasts: string[] = []++ w.env.set('HOME', HOME)+ if (Object.keys(files).some(f => f.startsWith(CLONE))) w.dirs.add(CLONE)+ if (files[`${CFG}/plugins/known_marketplaces.json`]?.includes('PWN')) w.dirs.add(CLONE)+ on('ui.toast', ($, e) => (toasts.push(e.text), { value: undefined }))+ on('clock.now', () => ({ value: Date.now() }))+ return { w, toasts }+}++describe('startup self-check: a mod that is not fully loaded says so once, in a toast', () => {+ test('a stale marketplace clone with the console plugin enabled but absent from it', async ($, on) => {+ const { toasts } = rig(on, ALL, { [`${CFG}/plugins/known_marketplaces.json`]: known, [manifest('ruflo-mods')]: '{}', [manifest('ruflo-swarm')]: '{}' })++ await $.session.start(START)++ expect(toasts).toHaveLength(1)+ expect(toasts[0]).toContain('ruflo-console')+ expect(toasts[0]).toMatch(/stale/i)+ expect(toasts[0]).toContain('claude plugin marketplace update ruflo')+ expect(toasts[0]).not.toContain('\n')+ expect(toasts[0]!.length).toBeLessThanOrEqual(120)+ })++ test('says nothing when every enabled plugin is in the clone', async ($, on) => {+ const { toasts } = rig(on, ALL, { [`${CFG}/plugins/known_marketplaces.json`]: known, [manifest('ruflo-mods')]: '{}', [manifest('ruflo-swarm')]: '{}', [manifest('ruflo-console')]: '{}' })++ await $.session.start(START)++ expect(toasts).toEqual([])+ })++ test('says nothing about a plugin that is not enabled, or one switched off on purpose', async ($, on) => {+ const { toasts } = rig(on, { 'ruflo-mods@ruflo': true, 'ruflo-console@ruflo': false }, { [`${CFG}/plugins/known_marketplaces.json`]: known, [manifest('ruflo-mods')]: '{}' })++ await $.session.start(START)++ expect(toasts).toEqual([])+ })++ test('a cached install still loads when the clone is stale: nothing to warn about', async ($, on) => {+ const cache = `${CFG}/plugins/cache/ruflo/ruflo-console/1.0.0`+ const { w, toasts } = rig(on, ALL, {+ [`${CFG}/plugins/known_marketplaces.json`]: known,+ [manifest('ruflo-mods')]: '{}',+ [manifest('ruflo-swarm')]: '{}',+ [`${CFG}/plugins/installed_plugins.json`]: JSON.stringify({ version: 2, plugins: { 'ruflo-console@ruflo': [{ scope: 'user', installPath: cache }] } }),+ })++ w.dirs.add(cache)+ await $.session.start(START)++ expect(toasts).toEqual([])+ })++ test('no clone yet (a fresh config): nothing is stale, so nothing is said', async ($, on) => {+ const { toasts } = rig(on, ALL, { [`${CFG}/plugins/known_marketplaces.json`]: known })++ await $.session.start(START)++ expect(toasts).toEqual([])+ })++ test('unreadable files, a missing home, or a refused toast never fail the session', async ($, on) => {+ const { w } = rig(on, ALL)++ w.env.delete('HOME')+ await expect($.session.start(START)).resolves.toBeDefined()+ })++ test('the selfCheck option turns it off', { options: { selfCheck: false } }, async ($, on) => {+ const { toasts } = rig(on, ALL, { [`${CFG}/plugins/known_marketplaces.json`]: known, [manifest('ruflo-mods')]: '{}', [manifest('ruflo-swarm')]: '{}' })++ await $.session.start(START)++ expect(toasts).toEqual([])+ })++ test('hostile text in the files never reaches the toast: only fixed plugin names are spoken', async ($, on) => {+ const evil = JSON.stringify({ ruflo: { source: { source: 'github', repo: 'ruvnet/ruflo' }, installLocation: `${CLONE}\u001b]0;PWN\u0007` } })+ const { toasts } = rig(on, ALL, { [`${CFG}/plugins/known_marketplaces.json`]: evil })++ await $.session.start(START)++ for (const t of toasts) expect(t).not.toMatch(/PWN|\u001b/)+ })+})diff --git a/v3/docs/adr/ADR-404-claude-code-mods-function-hooks.md b/v3/docs/adr/ADR-404-claude-code-mods-function-hooks.mdindex 25c54cc64e..be867c753e 100644--- a/v3/docs/adr/ADR-404-claude-code-mods-function-hooks.md+++ b/v3/docs/adr/ADR-404-claude-code-mods-function-hooks.md@@ -289,3 +289,13 @@ Status: Proposed. This amends "A separate, opt-in plugin" above. The plugin stay- **`claude plugin uninstall --scope project` edits settings too.** It removes the plugin's `enabledPlugins` entry itself.- **Headless runs load once the marketplace is known.** After `ruflo init` has added the marketplace to the config dir, `claude -p "/ruflo-mods"` loads the mod and prints its report. This is the e2e live check. It authenticates with `CLAUDE_CODE_OAUTH_TOKEN`; no credential file is copied.- **A directory marketplace works, live.** A `directory` source loaded `ruflo-mods` in `claude -p` with no install record. An edit to the directory showed on the next run with no update or install in between. It was verified with a marker string changed between two runs.++## Addendum 2026-10-11: the doctor names each broken state; install is one operation; the mod says when it is not fully loaded++- **A switched-off plugin is not repaired by `ruflo mods install`.** Install never flips a `false` (section above). `doctor` used to answer a `false` with "not enabled", fix `ruflo mods install`, which changes nothing. It now says the plugin is disabled in that file and prints `claude plugin enable ruflo-mods@ruflo --scope <scope>`. A plugin installed for this project but enabled nowhere gets the same repair.+- **`partial install` finding.** Some of the three mod plugins enabled and not the others, a plugin enabled with no `ruflo` marketplace declared anywhere, or keys the install record says ruflo added that the settings no longer carry. Repair: `ruflo mods install`, which is idempotent and adds exactly what is missing.+- **Every warning or failure carries a one-line `fix`.** The exceptions are facts only the engine can change (Claude Code serving function hooks off for the account). A fresh config where nothing is cloned says that a headless `claude -p` run clones nothing, so the mod is absent there.+- **`ruflo mods doctor --strict`** exits 1 on a warning as well as on a failure, for CI. Without it the exit code is as before (1 only on a failure).+- **Install is one operation.** The settings file and the install record are written together; if the record cannot be written the settings go back as they were (or the file ruflo created is removed), so nothing is left that `uninstall` cannot find. A second run changes nothing and writes no second backup.+- **Startup self-check (mod option `selfCheck`, default on).** At `session.start`, when `ruflo-console` or `ruflo-swarm` is enabled in settings but missing from the marketplace clone with no cached install, the mod says so once in a toast: a fixed line naming the plugin(s) and `claude plugin marketplace update ruflo`. Read-only, fail-open, no repository text in the line, nothing for the model. A fresh config with no clone yet says nothing (Claude Code clones at the next interactive start). It cannot know a plugin failed to load for another reason; it checks the cause the doctor already knows is silent.+- **Not done:** the self-check does not read which plugins the engine actually loaded (the `engine.create` input lists them; not used here), and `/ruflo-mods` stays an alias of `/ruflo mods` (ADR-406), now held by a smoke step.diff --git a/v3/docs/adr/ADR-477-mod-toasts.md b/v3/docs/adr/ADR-477-mod-toasts.mdindex 8891b75fdd..93b2fb3e32 100644--- a/v3/docs/adr/ADR-477-mod-toasts.md+++ b/v3/docs/adr/ADR-477-mod-toasts.md@@ -217,3 +217,25 @@ the update toasts are in `plugins/ruflo-console/hooks/update-flow.ts` (see ADR-4### What's newThe What's new page (ADR-478) raises one console-source info toast per new version.++## Addendum 2026-10-11: what the engine does with a toast's text (measured)++Colour and animation in a toast were asked for. A spike on Claude Code 2.1.289 (interactive, in tmux; a throwaway mod calling `$.ui.toast` once per case, five seconds apart, `capture-pane -e`) shows what the engine draws:++| text in the toast | what the engine drew |+|---|---|+| plain text | drawn, in a one-slot box in the header |+| `✓ ⚠ ✗ › ⏳ 🔥 ▶` | drawn as written |+| SGR colour (`ESC[38;5;208m`, bold, red) | the ESC byte becomes U+FFFD and the rest (`[38;5;208m`) is drawn as literal text: **no colour** |+| OSC 8 link | swallowed with the link text; no hyperlink |+| OSC 0 (window title) | not run; ESC and BEL become U+FFFD, the rest is drawn |+| bidi override (U+202E) | becomes U+FFFD |+| carriage return, `ESC[2K`, `ESC[1G` | become U+FFFD; nothing is cleared or overwritten |++Four calls made in the same instant leave one visible toast: the slot shows the newest, so a toast is not a stack. Decisions:++- **Icons only.** The level prefixes (`› ✓ ⚠ ✗`) of section 2.2 are the supported styling. Colour cannot be carried by the text, and the washing in section 2.2 (escapes removed first) is therefore not a loss.+- **No animation through toasts.** A static line in a one-slot box. Animation and colour belong to a surface the console draws itself (a band or a pane), not to `$.ui.toast`. That is not built here.+- The engine's own neutralising (U+FFFD for controls) is a second layer under ours, not a reason to relax ours: a plugin's text is washed before it reaches the engine.++Not measured: Windows terminals, other terminals than tmux, the desktop and VS Code surfaces.