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

feat(ruflo-console): 0.14.0 — every plugin has a home section; every section ends with a Launch section for its plugins' commands

ruvfc23d0d5bdcb
diff --git a/plugins/ruflo-console/.claude-plugin/plugin.json b/plugins/ruflo-console/.claude-plugin/plugin.json
index 58e9393887..7613cd87e8 100644
--- a/plugins/ruflo-console/.claude-plugin/plugin.json
+++ b/plugins/ruflo-console/.claude-plugin/plugin.json
@@ -1,7 +1,7 @@
{
"name": "ruflo-console",
"description": "ruflo's cockpit inside Claude Code and the one /ruflo command for every ruflo mod (function hooks, early access). Views: overview with health alerts, swarm topology graph, claims flow with TTL rings, federation map, plugin health matrix, learning curve and pipeline, MetaHarness radar and audit trend, memory, cost gauge, agent timeline, approvals queue, event stream, a main menu, an x.ruv.io federation board, an AI terminal (codex, claude or both in remembered sessions, streamed), Skills (npx skills), a Hive-Mind view, a MetaHarness lab, agent drill-down; a command palette for confirm-gated actions through the ruflo CLI; a band above the prompt. Reads ruflo's files and the CLI's local JSON; anything not measured reads n/a; no network by default.",
- "version": "0.13.1",
+ "version": "0.14.0",
"author": {
"name": "ruvnet",
"url": "https://github.com/ruvnet"
diff --git a/plugins/ruflo-console/hooks/ask-claude.ts b/plugins/ruflo-console/hooks/ask-claude.ts
index a56102fc8b..22b479ac1d 100644
--- a/plugins/ruflo-console/hooks/ask-claude.ts
+++ b/plugins/ruflo-console/hooks/ask-claude.ts
@@ -9,6 +9,7 @@
import { plain } from './data/parse'
import type { Host } from './host'
import { mcOf } from './mission-control'
+import { pluginsOfView } from './plugin-map'
import { blocksGuidance, screenText } from './mission-options'
import type { Runner } from './runner'
import { VIEWS, type State, type ViewId } from './state'
@@ -95,6 +96,8 @@ export type AskActions = {
aside: (question?: string, view?: ViewId) => void
/** Runs the slash command that fits the view, when the session lists it. */
slash: (view?: ViewId) => void
+ /** Runs any slash command the session lists (the Launch row), asking first. */
+ launch: (slash: string) => void
}
const wired = new WeakMap<State, AskActions>()
@@ -102,6 +105,23 @@ const wired = new WeakMap<State, AskActions>()
/** The ask actions the console was wired with, for the palette and the headless commands. */
export const askWired = (state: State): AskActions | undefined => wired.get(state)
+/** True for a plain `plugin:command` name the session lists. */
+export const launchable = (state: State, slash: string): boolean => /^[a-z0-9-]+:[A-Za-z0-9._-]+$/.test(slash) && state.commandNames.includes(slash)
+
+/** The commands a section can launch: those of the plugins it owns (hooks/plugin-map.ts) that the session lists, by plugin. */
+export function launchOf(state: State, view: ViewId): { plugin: string; slashes: string[] }[] {
+ const owned = new Set(pluginsOfView(view))
+ const groups = new Map<string, string[]>()
+
+ for (const slash of new Set(state.commandNames)) {
+ const plugin = slash.slice(0, Math.max(0, slash.indexOf(':')))
+
+ if (owned.has(plugin) && launchable(state, slash)) (groups.get(plugin) ?? groups.set(plugin, []).get(plugin))?.push(slash)
+ }
+
+ return [...groups.entries()].map(([plugin, slashes]) => ({ plugin, slashes: slashes.sort() })).sort((x, y) => x.plugin.localeCompare(y.plugin))
+}
+
export const slashFor = (state: State, view: ViewId): string | null => {
const slash = VIEW_ASK[view].slash
@@ -152,26 +172,32 @@ export function askActions(state: State, host: Host, runner: Runner, act: () =>
if (slash === null) return say('no such command here', false, 'the plugin for this section is not loaded in this session')
- runner.ask(
- {
- label: `run /${slash} in the main Claude UI`,
- scope: 'ask',
- args: [],
- shows: `/${slash}`,
- expect: 'the command in the main conversation',
- note: 'Starts a Claude Code turn (billed as any turn is); mid-turn it is only prepared in the prompt box.',
- run: async () => {
- try {
- if (state.turnActive) await host.fillPrompt(`/${slash}`)
- else await host.runSlash(slash, '')
- } catch (error) {
- say(`/${slash} did not run`, false, plain(error instanceof Error ? error.message : String(error), 140))
- }
- },
- },
- 'nothing to run',
- )
+ launch(slash)
},
+ launch: slash => (launchable(state, slash) ? launch(slash) : say(`/${slash} is not available`, false, 'the plugin is not loaded in this session')),
+ }
+
+ /** Runs a slash command in the main Claude UI: asks first (it starts a turn); mid-turn it only fills the prompt box. */
+ function launch(slash: string): void {
+ runner.ask(
+ {
+ label: `run /${slash} in the main Claude UI`,
+ scope: 'ask',
+ args: [],
+ shows: `/${slash}`,
+ expect: 'the command in the main conversation',
+ note: 'Starts a Claude Code turn (billed as any turn is); mid-turn it is only prepared in the prompt box.',
+ run: async () => {
+ try {
+ if (state.turnActive) await host.fillPrompt(`/${slash}`)
+ else await host.runSlash(slash, '')
+ } catch (error) {
+ say(`/${slash} did not run`, false, plain(error instanceof Error ? error.message : String(error), 140))
+ }
+ },
+ },
+ 'nothing to run',
+ )
}
wired.set(state, actions)
diff --git a/plugins/ruflo-console/hooks/mission-skills.ts b/plugins/ruflo-console/hooks/mission-skills.ts
index 4a06f7b115..be7258d357 100644
--- a/plugins/ruflo-console/hooks/mission-skills.ts
+++ b/plugins/ruflo-console/hooks/mission-skills.ts
@@ -25,6 +25,8 @@ export const MISSION_SKILLS: readonly MissionSkill[] = [
/** The slash commands present now (loaded when Mission Control opens); a skill is offered when its command is among them. */
export async function loadCommandNames(state: State, host: Host): Promise<void> {
state.commandNames = await host.listCommands().catch(() => [])
+ // The Launch rows and the ask buttons depend on it: redraw now that it is known.
+ host.invalidate()
}
export const slashOf = (skill: MissionSkill): string => `${GOALS_PLUGIN}:${skill.id}`
diff --git a/plugins/ruflo-console/hooks/plugin-map.ts b/plugins/ruflo-console/hooks/plugin-map.ts
new file mode 100644
index 0000000000..d9e9ab65c8
--- /dev/null
+++ b/plugins/ruflo-console/hooks/plugin-map.ts
@@ -0,0 +1,71 @@
+/**
+ * Which console section owns each ruflo plugin: the section that launches its slash commands (the Launch row) and answers
+ * "ask Claude" about it. Every plugin directory under `plugins/` appears here, and a test fails when one is added without a
+ * line, so no plugin is ever unreachable from the console. A plugin with no section of its own says why (`catalogOnly`) and is
+ * reached from the Plugin Catalog. Pure data.
+ */
+import type { ViewId } from './state'
+
+export type PluginHome = { view: ViewId; /** Set when the plugin has no surface of its own yet: why, and where it is reached instead. */ catalogOnly?: string }
+
+const home = (view: ViewId): PluginHome => ({ view })
+const catalog = (why: string): PluginHome => ({ view: 'market', catalogOnly: why })
+
+export const PLUGIN_MAP: Readonly<Record<string, PluginHome>> = {
+ 'ruflo-adr': home('devtools'),
+ 'ruflo-agent': home('swarm'),
+ 'ruflo-agentdb': home('memory'),
+ 'ruflo-agntcy': home('federation'),
+ 'ruflo-aidefence': home('secure'),
+ 'ruflo-ai-team': home('swarm'),
+ 'ruflo-arena': home('evolve'),
+ 'ruflo-autopilot': home('automate'),
+ 'ruflo-bbs-federation': home('xruv'),
+ 'ruflo-browser': home('devtools'),
+ 'ruflo-business-pods': home('federation'),
+ 'ruflo-chatgpt-federation': home('federation'),
+ 'ruflo-console': catalog('this mod: it is the console'),
+ 'ruflo-core': home('overview'),
+ 'ruflo-cost-tracker': home('cost'),
+ 'ruflo-daa': home('neural'),
+ 'ruflo-ddd': home('devtools'),
+ 'ruflo-deepseek-harness': home('terminal'),
+ 'ruflo-docs': home('devtools'),
+ 'ruflo-federation': home('federation'),
+ 'ruflo-goals': home('missions'),
+ 'ruflo-graph-intelligence': home('vector'),
+ 'ruflo-intelligence': home('learning'),
+ 'ruflo-iot-cognitum': catalog('a device fleet with firmware writes: launched from the Plugin Catalog until the Domains view'),
+ 'ruflo-jujutsu': home('devtools'),
+ 'ruflo-knowledge-graph': home('memory'),
+ 'ruflo-loop-workers': home('automate'),
+ 'ruflo-market-data': catalog('a market-data domain plugin: launched from the Plugin Catalog until the Domains view'),
+ 'ruflo-metaharness': home('metaharness'),
+ 'ruflo-migrations': home('devtools'),
+ 'ruflo-mods': home('plugins'),
+ 'ruflo-music': catalog('a creative-domain plugin that may spend on generation: launched from the Plugin Catalog until the Domains view'),
+ 'ruflo-neural-trader': catalog('a trading domain plugin (never live from the console): launched from the Plugin Catalog until the Domains view'),
+ 'ruflo-observability': home('timeline'),
+ 'ruflo-plugin-creator': home('plugins'),
+ 'ruflo-rag-memory': home('memory'),
+ 'ruflo-ruos': home('swarm'),
+ 'ruflo-ruvector': home('vector'),
+ 'ruflo-ruvllm': home('neural'),
+ 'ruflo-rvf': home('vector'),
+ 'ruflo-security-audit': home('secure'),
+ 'ruflo-sparc': home('missions'),
+ 'ruflo-swarm': home('swarm'),
+ 'ruflo-testgen': home('devtools'),
+ 'ruflo-workflows': home('automate'),
+ 'ruflo-x-gateway': home('xruv'),
+}
+
+/** The section that owns a plugin (by directory name, or by the `plugin:command` slash name). */
+export const homeOf = (pluginOrSlash: string): ViewId | null => PLUGIN_MAP[pluginOrSlash.split(':')[0] ?? '']?.view ?? null
+
+/** The plugins a section owns, in name order: what its Launch row can offer. */
+export const pluginsOfView = (view: ViewId): string[] =>
+ Object.entries(PLUGIN_MAP)
+ .filter(([, entry]) => entry.view === view)
+ .map(([plugin]) => plugin)
+ .sort()
diff --git a/plugins/ruflo-console/hooks/views/launch.ts b/plugins/ruflo-console/hooks/views/launch.ts
new file mode 100644
index 0000000000..60b3b9daff
--- /dev/null
+++ b/plugins/ruflo-console/hooks/views/launch.ts
@@ -0,0 +1,39 @@
+import type { RenderElement } from 'claude-code'
+
+import { launchOf } from '../ask-claude'
+import { VIEWS } from '../state'
+import { clip, row, section, text, THEME, type Ctx } from './common'
+
+const noteOf = (plugin: string): string => plugin.replace(/^ruflo-?/, '') || plugin
+
+/**
+ * The Launch section at the foot of a page: the slash commands of the ruflo plugins this section owns, each a button that asks first
+ * and then runs in the main Claude UI (mid-turn it only fills the prompt box). Folded by default; nothing is drawn when the session
+ * lists no command for this section's plugins.
+ */
+export function launchRows(ctx: Ctx): RenderElement[] {
+ const view = ctx.state.view
+
+ if (view === 'terminal' || view === 'agent' || !VIEWS.some(entry => entry.id === view)) return []
+
+ const groups = launchOf(ctx.state, view)
+
+ if (groups.length === 0) return []
+
+ const total = groups.reduce((sum, group) => sum + group.slashes.length, 0)
+ const body = groups.flatMap(group => [
+ ctx.kit.Text({ bold: true, color: THEME.ok, children: ` ${noteOf(group.plugin)}` }),
+ ...group.slashes.map(slash =>
+ row(
+ ctx,
+ [
+ ctx.kit.Button({ key: `launch-${slash}`, label: ` /${clip(slash, Math.max(20, ctx.columns - 24))} `, plain: true, onPress: () => ctx.act.ask.launch(slash) }),
+ ctx.kit.Button({ key: `launch-run-${slash}`, label: ' â–¸ run', plain: true, dimColor: true, onPress: () => ctx.act.ask.launch(slash) }),
+ ],
+ `launch-row-${slash}`,
+ ),
+ ),
+ ])
+
+ return section(ctx, 'launch', 'Launch', `${total} command${total === 1 ? '' : 's'} from ${groups.length} plugin${groups.length === 1 ? '' : 's'}, run in the Claude UI (asks first)`, [...body, text(ctx, ' each starts a Claude Code turn: it asks first, and mid-turn only fills the prompt box', { dimColor: true })], false)
+}
diff --git a/plugins/ruflo-console/hooks/views/pane.ts b/plugins/ruflo-console/hooks/views/pane.ts
index 75acdd978f..4945d1d200 100644
--- a/plugins/ruflo-console/hooks/views/pane.ts
+++ b/plugins/ruflo-console/hooks/views/pane.ts
@@ -7,6 +7,7 @@ import type { RenderElement } from 'claude-code'
import { HELP } from '../commands'
import { slashFor } from '../ask-claude'
+import { launchRows } from './launch'
import { isBooting, isCompactPane, NAV_STYLES, VIEWS, type ViewId } from '../state'
import { agentView } from './agent'
import { automateView } from './automate'
@@ -248,7 +249,10 @@ export function paneView(ctx: Ctx): RenderElement {
? col(ctx, [ctx.kit.Raster(boot.toRaster('boot'))], 'boot')
: col(ctx, [text(ctx, 'CONNECT 115200 · RUFLO AGENT SWARM CONSOLE · loading…', { bold: true, color: THEME.head })], 'boot')
}
- const body = ctx.state.palette.isOpen ? paletteView(ctx) : ctx.state.isHelp ? help(ctx) : BODIES[ctx.state.view](ctx)
+ const shownBody = ctx.state.palette.isOpen ? paletteView(ctx) : ctx.state.isHelp ? help(ctx) : BODIES[ctx.state.view](ctx)
+ // Every section ends with its Launch section: the commands of the plugins it owns, run in the Claude UI.
+ const launch = ctx.state.palette.isOpen || ctx.state.isHelp ? [] : launchRows(ctx)
+ const body = launch.length === 0 ? shownBody : col(ctx, [shownBody, ...launch], 'body')
const confirm = confirmRow(ctx)
const header = ctx.pictures.get('header')
const isCompact = isCompactPane(ctx.state)
diff --git a/plugins/ruflo-console/scripts/smoke.sh b/plugins/ruflo-console/scripts/smoke.sh
index 4345d598eb..2aac411f25 100755
--- a/plugins/ruflo-console/scripts/smoke.sh
+++ b/plugins/ruflo-console/scripts/smoke.sh
@@ -11,9 +11,9 @@ step() { printf "→ %s ... " "$1"; }
ok() { printf "PASS\n"; PASS=$((PASS+1)); }
bad() { printf "FAIL: %s\n" "$1"; FAIL=$((FAIL+1)); }
-step "1. plugin.json declares ruflo-console 0.13.1"
+step "1. plugin.json declares ruflo-console 0.14.0"
grep -q '"name": "ruflo-console"' "$ROOT/.claude-plugin/plugin.json" \
- && grep -q '"version": "0.13.1"' "$ROOT/.claude-plugin/plugin.json" && ok || bad "name/version"
+ && grep -q '"version": "0.14.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" \
diff --git a/plugins/ruflo-console/tests/ask-claude.spec.ts b/plugins/ruflo-console/tests/ask-claude.spec.ts
index e3e71efd18..1047af87ff 100644
--- a/plugins/ruflo-console/tests/ask-claude.spec.ts
+++ b/plugins/ruflo-console/tests/ask-claude.spec.ts
@@ -6,7 +6,7 @@
import { describe, expect, it } from 'vitest'
import type { ActionSpec } from '../hooks/actions'
-import { askActions, askPrompt, scrub, slashFor, VIEW_ASK } from '../hooks/ask-claude'
+import { askActions, askPrompt, launchOf, scrub, slashFor, VIEW_ASK } from '../hooks/ask-claude'
import type { Host } from '../hooks/host'
import type { Runner } from '../hooks/runner'
import { newState, VIEWS, type State } from '../hooks/state'
@@ -145,4 +145,31 @@ describe('ask Claude about this', () => {
await calls.asked[0]?.run?.()
expect(calls.slashes).toEqual(['ruflo-cost-tracker:ruflo-cost'])
})
+
+ it('a section launches the commands of the plugins it owns, grouped, and nothing else', () => {
+ const { state } = setup()
+
+ state.commandNames = ['ruflo-aidefence:aidefence', 'ruflo-security-audit:audit', 'ruflo-cost-tracker:ruflo-cost', 'other:thing', 'ruflo-aidefence:aidefence', 'not a command']
+ expect(launchOf(state, 'secure')).toEqual([
+ { plugin: 'ruflo-aidefence', slashes: ['ruflo-aidefence:aidefence'] },
+ { plugin: 'ruflo-security-audit', slashes: ['ruflo-security-audit:audit'] },
+ ])
+ expect(launchOf(state, 'cost')).toEqual([{ plugin: 'ruflo-cost-tracker', slashes: ['ruflo-cost-tracker:ruflo-cost'] }])
+ expect(launchOf(state, 'timeline')).toEqual([])
+ })
+
+ it('a launch asks first, then runs the command; an unlisted or malformed one is refused and never asked', async () => {
+ const { state, calls, actions } = setup()
+
+ state.commandNames = ['ruflo-ruos:deploy']
+ actions.launch('ruflo-ruos:deploy')
+ expect(calls.slashes).toEqual([])
+ expect(calls.asked[0]?.label).toBe('run /ruflo-ruos:deploy in the main Claude UI')
+ expect(calls.asked[0]?.note).toContain('billed')
+ await calls.asked[0]?.run?.()
+ expect(calls.slashes).toEqual(['ruflo-ruos:deploy'])
+ actions.launch('ruflo-ruos:run')
+ actions.launch('rm -rf /')
+ expect(calls.asked).toHaveLength(1)
+ })
})
diff --git a/plugins/ruflo-console/tests/matrix.test.ts b/plugins/ruflo-console/tests/matrix.test.ts
index 191ed7472b..c02285ce6c 100644
--- a/plugins/ruflo-console/tests/matrix.test.ts
+++ b/plugins/ruflo-console/tests/matrix.test.ts
@@ -66,4 +66,35 @@ describe('matrix: every section', () => {
}
})
}
+
+ test('launch: a section with plugin commands ends with a Launch section that asks first; one without has none', { options: { boot: false } }, async ($, on) => {
+ const world = worldOf(on, RUFLO_FILES, { commands: ['ruflo-cost-tracker:ruflo-cost', 'ruflo-adr:adr'] })
+
+ world.respond = missionCli
+ mock.clock(on)
+ await $.session.start(SESSION)
+ await $.command.run(command('cost'))
+
+ const pane = await $.ui.mount({ ...paneAt(150), surface: 'terminal' as const, plugin: PLUGIN })
+
+ await pane.drawn()
+ expect(textOf(await pane.drawn())).toContain('LAUNCH')
+ expect(elementsOf(await pane.drawn(), 'Button').map(keyOf)).toContain('sec-launch')
+ await pane.press({ key: 'sec-launch' })
+ expect(elementsOf(await pane.drawn(), 'Button').map(keyOf)).toContain('launch-ruflo-cost-tracker:ruflo-cost')
+ expect(elementsOf(await pane.drawn(), 'Button').map(keyOf)).not.toContain('launch-ruflo-adr:adr')
+ await pane.press({ key: 'launch-ruflo-cost-tracker:ruflo-cost' })
+ expect(textOf(await pane.drawn())).toContain('Confirm: run /ruflo-cost-tracker:ruflo-cost in the main Claude UI')
+ expect(world.prompts).toEqual([])
+ await pane.unmount()
+
+ // Timeline owns ruflo-observability, which this session does not list: no Launch section.
+ await $.command.run(command('timeline'))
+
+ const other = await $.ui.mount({ ...paneAt(150), surface: 'terminal' as const, plugin: PLUGIN })
+
+ await other.drawn()
+ expect(elementsOf(await other.drawn(), 'Button').map(keyOf)).not.toContain('sec-launch')
+ await other.unmount()
+ })
})
diff --git a/plugins/ruflo-console/tests/plugin-coverage.spec.ts b/plugins/ruflo-console/tests/plugin-coverage.spec.ts
new file mode 100644
index 0000000000..a8f3d8cfa9
--- /dev/null
+++ b/plugins/ruflo-console/tests/plugin-coverage.spec.ts
@@ -0,0 +1,53 @@
+/**
+ * Plugin coverage: every ruflo plugin directory has a home section in the console, no entry names a plugin that is gone, every
+ * home is a real view, and a plugin that has no surface of its own says why. A new plugin added without a line fails here.
+ */
+import { existsSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+import { homeOf, PLUGIN_MAP, pluginsOfView } from '../hooks/plugin-map'
+import { VIEWS } from '../hooks/state'
+
+const PLUGINS = join(__dirname, '..', '..')
+const onDisk = readdirSync(PLUGINS, { withFileTypes: true })
+ .filter(entry => entry.isDirectory() && existsSync(join(PLUGINS, entry.name, '.claude-plugin', 'plugin.json')))
+ .map(entry => entry.name)
+ .sort()
+
+describe('plugin coverage', () => {
+ it('finds the plugin directories (the guard is not checking nothing)', () => {
+ expect(onDisk.length).toBeGreaterThan(40)
+ expect(onDisk).toContain('ruflo-console')
+ })
+
+ it('every plugin directory has a home section, and no home is for a plugin that is gone', () => {
+ expect(onDisk.filter(name => PLUGIN_MAP[name] === undefined), 'unmapped plugins: add a line to hooks/plugin-map.ts').toEqual([])
+ expect(Object.keys(PLUGIN_MAP).filter(name => !onDisk.includes(name)), 'stale entries').toEqual([])
+ })
+
+ it('every home is a real section, and a plugin without a surface of its own says why', () => {
+ const views = new Set(VIEWS.map(view => view.id))
+
+ for (const [plugin, entry] of Object.entries(PLUGIN_MAP)) {
+ expect(views.has(entry.view), plugin).toBe(true)
+ if (entry.catalogOnly !== undefined) {
+ expect(entry.view, plugin).toBe('market')
+ expect(entry.catalogOnly.length, plugin).toBeGreaterThan(20)
+ }
+ }
+ })
+
+ it('homeOf reads a plugin name or a slash name; pluginsOfView lists what a section owns', () => {
+ expect(homeOf('ruflo-cost-tracker')).toBe('cost')
+ expect(homeOf('ruflo-ruos:deploy')).toBe('swarm')
+ expect(homeOf('not-a-plugin:thing')).toBeNull()
+ expect(pluginsOfView('secure')).toEqual(['ruflo-aidefence', 'ruflo-security-audit'])
+ })
+
+ it('every section that owns a plugin has an ask entry (so each home can also be asked about)', async () => {
+ const { VIEW_ASK } = await import('../hooks/ask-claude')
+
+ for (const entry of Object.values(PLUGIN_MAP)) expect(VIEW_ASK[entry.view], entry.view).toBeDefined()
+ })
+})
diff --git a/v3/docs/adr/ADR-408-ruflo-console-mission-control.md b/v3/docs/adr/ADR-408-ruflo-console-mission-control.md
index 34bc0b6f5d..214c5f7dcd 100644
--- a/v3/docs/adr/ADR-408-ruflo-console-mission-control.md
+++ b/v3/docs/adr/ADR-408-ruflo-console-mission-control.md
@@ -68,6 +68,7 @@ Writes are confirm-gated with the exact argv. Remembered actions are not offered
- **✦ Ask Claude** is in every page's footer (`hooks/ask-claude.ts`, `VIEW_ASK` has a row per view): the view's own text (what `/ruflo dump <view>` prints) goes to the primary session as a visible prompt, or a `/btw` aside, with a question (the view's default, or `/ruflo ask <question>`). It asks first with the exact text and a spend note; mid-turn it only fills the prompt box. The screen's lines are quoted data (each behind `│`, so none can start a command), secrets are redacted first (keys, tokens, JWTs, bearer headers, PEM blocks, NAME=value of a secret name), the terminal and Settings share nothing, and a typed question is screened by AIDefence.
- **â–¸ /plugin:command** appears beside it when the session lists the command of the ruflo plugin that fits the view (cost, security audit, swarm, memory, ...); it asks first.
+- **Plugin map and Launch section (0.14.0).** `hooks/plugin-map.ts` gives each directory under `plugins/` one owning section, or says why it is reached from the Plugin Catalog only (domain plugins that can spend or write devices, and the console itself); `tests/plugin-coverage.spec.ts` fails on an unmapped plugin, a stale entry or a home that is not a view. Every section ends with a folded **Launch** section (`views/launch.ts`) listing the slash commands of the plugins it owns that the session lists; each button asks first, then runs the command in the main Claude UI (mid-turn it only fills the prompt box). A section whose plugins are not loaded draws nothing; the page redraws when the command list arrives.
- **Regression matrix** (`tests/matrix.test.ts`): every view, at 80 and 150 columns, draws without error text, names itself, has no duplicate element keys, and its Ask button asks first and then sends exactly one prompt (quoted data, no secret). `tests/ask-claude.spec.ts` covers the table, the scrubber and delivery. `scripts/e2e-smoke.sh` opens every view in a real Claude Code with no AI turn and no write (live only with `RUFLO_E2E_LIVE=1`, otherwise it skips). Smoke steps 14-16 run every pure spec, the e2e skip path and the table coverage.
## 11. Answers open where they were asked (0.13.1)