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): Sandbox page (tmux, RVF branches, RVM info); Plugins moves to TOOLS

ruv4cc9b0faa2d6
diff --git a/plugins/ruflo-console/hooks/ask-claude.ts b/plugins/ruflo-console/hooks/ask-claude.ts
index 22b479ac1d..25390aa048 100644
--- a/plugins/ruflo-console/hooks/ask-claude.ts
+++ b/plugins/ruflo-console/hooks/ask-claude.ts
@@ -44,6 +44,7 @@ export const VIEW_ASK: Record<ViewId, ViewAsk> = {
vector: { default: 'How should I use these vector stores and queries for this project?', slash: 'ruflo-ruvector:vector' },
evolve: { default: 'Is this self-evolution loop safe and making progress? What should be promoted or rejected?', slash: 'ruflo-intelligence:intelligence' },
devtools: { default: 'Which of these tools should I use for the change I am making?', slash: 'ruflo-jujutsu:jujutsu' },
+ sandbox: { default: 'Which sandbox fits what I want to try, and is anything running here I should end?', slash: 'ruflo-rvf:rvf' },
market: { default: 'Which of these plugins would help most for what I am doing?' },
settings: { default: 'Which of these settings should I change for how I work?' },
agent: { default: 'What is this agent doing, and is anything wrong with it?' },
diff --git a/plugins/ruflo-console/hooks/data/devtools.ts b/plugins/ruflo-console/hooks/data/devtools.ts
index b7b0313f47..fae6897021 100644
--- a/plugins/ruflo-console/hooks/data/devtools.ts
+++ b/plugins/ruflo-console/hooks/data/devtools.ts
@@ -7,13 +7,13 @@ import { jsonAfter } from './cli'
import { plain, recordOf } from './parse'
import { labLines } from '../mh-lab'
-export type DevField = 'ref' | 'path' | 'label' | 'url' | 'target' | 'query' | 'task' | 'cmd' | 'id' | 'note'
+export type DevField = 'ref' | 'path' | 'label' | 'url' | 'target' | 'query' | 'task' | 'cmd' | 'id' | 'note' | 'session' | 'send'
export type DevFields = Record<DevField, string>
-export const DEV_FIELDS: readonly DevField[] = ['ref', 'path', 'label', 'url', 'target', 'query', 'task', 'cmd', 'id', 'note']
+export const DEV_FIELDS: readonly DevField[] = ['ref', 'path', 'label', 'url', 'target', 'query', 'task', 'cmd', 'id', 'note', 'session', 'send']
-export const emptyFields = (): DevFields => ({ ref: 'HEAD', path: '', label: '', url: '', target: '', query: '', task: '', cmd: '', id: '', note: '' })
+export const emptyFields = (): DevFields => ({ ref: 'HEAD', path: '', label: '', url: '', target: '', query: '', task: '', cmd: '', id: '', note: '', session: '', send: '' })
const CONTROL = /[\u0000-\u001f\u007f]/
@@ -58,6 +58,23 @@ const RULES: Record<DevField, { test: (text: string) => string | null; rule: str
cmd: { test: text => prose(text, 200), rule: 'one command line: 1-200 characters, no newline or control character, not starting with -' },
id: { test: text => (/^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/.test(text.trim()) ? text.trim() : null), rule: 'an id: letters, digits _ . : -, at most 64, not starting with -' },
note: { test: text => prose(text, 200), rule: 'a note: 1-200 characters, no control characters, not starting with -' },
+ session: { test: text => (/^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$/.test(text.trim()) ? text.trim() : null), rule: 'a sandbox name: letters, digits _ -, at most 40, not starting with _ or - (the console adds the ruflo-sb- prefix)' },
+ // tmux splits an argument that ends in a semicolon into two commands, so a command line ending in one is refused, not typed.
+ send: { test: text => { const value = prose(text, 200); return value === null || value.endsWith(';') ? null : value }, rule: 'one command line to type: 1-200 characters, no control character, not starting with -, not ending in ;' },
+}
+
+/** A field's checked value, or null; `build` makes the argv only when every named field passes. */
+export const need = (fields: DevFields, names: readonly DevField[], build: (values: Record<DevField, string>) => readonly string[]): readonly string[] | null => {
+ const values = {} as Record<DevField, string>
+
+ for (const name of names) {
+ const value = fieldValue(name, fields[name])
+
+ if (value === null) return null
+ values[name] = value
+ }
+
+ return build(values)
}
/** A field's text as it may enter an argv, or null when it breaks the field's rule. */
diff --git a/plugins/ruflo-console/hooks/devtools.ts b/plugins/ruflo-console/hooks/devtools.ts
index 672f572e9e..cfedc676a3 100644
--- a/plugins/ruflo-console/hooks/devtools.ts
+++ b/plugins/ruflo-console/hooks/devtools.ts
@@ -7,15 +7,16 @@
* its reason, never a button that can only fail. Pure: entries, specs and closures; nothing here touches `$`.
*/
import type { ActionSpec } from './actions'
-import { devLines, fieldRule, fieldValue, tool, type DevField, type DevFields } from './data/devtools'
+import { devLines, fieldRule, fieldValue, need, tool, type DevField, type DevFields } from './data/devtools'
import type { Host } from './host'
import type { PaletteEntry } from './palette'
+import { SANDBOX, SANDBOX_GROUPS } from './sandbox'
import type { State } from './state'
/** `read`: local, $0, changes nothing. `local`: local compute that keeps nothing. Then writes, the network, money, deletes. */
export type DevCost = 'read' | 'local' | 'writes' | 'network' | 'spends' | 'deletes'
-export type DevGroup = 'github' | 'analyze' | 'cow' | 'wasm' | 'browser' | 'terminal' | 'providers' | 'plugins' | 'ruvllm' | 'daa' | 'brain' | 'managed' | 'maint'
+export type DevGroup = 'github' | 'analyze' | 'cow' | 'wasm' | 'browser' | 'terminal' | 'providers' | 'plugins' | 'ruvllm' | 'daa' | 'brain' | 'managed' | 'maint' | 'tmux' | 'rvm'
export type DevEntry = {
id: string
@@ -30,6 +31,12 @@ export type DevEntry = {
input?: DevField
/** The argv after the CLI prefix, from the fields; null when a field breaks its rule. */
args?: (fields: DevFields) => readonly string[] | null
+ /** A fixed command outside ruflo (tmux): the whole argv, run as it is, with no CLI prefix; null when a field breaks its rule. */
+ exec?: (fields: DevFields) => readonly string[] | null
+ /** The program the entry needs: while it is known missing, the row is n/a. */
+ needs?: 'tmux'
+ /** How its output reads, when `labLines` would not say it well. */
+ read?: (stdout: string, stderr: string, ok: boolean) => string[]
/** Not runnable from the console: the reason the row shows instead of a button. */
na?: string
note?: string
@@ -50,25 +57,12 @@ export const DEV_GROUPS: readonly { id: DevGroup; title: string; right: string }
{ id: 'daa', title: 'DAA ยท dynamic agents', right: '.claude-flow/daa ยท writes ask' },
{ id: 'managed', title: 'Managed agents', right: 'Anthropic cloud ยท every call asks' },
{ id: 'maint', title: 'Maintenance', right: 'cleanup ยท update ยท migrate ยท process ยท appliance' },
+ ...SANDBOX_GROUPS,
]
const SESSION = 'ruflo-console'
const SHOT = 'ruflo-console-screenshot.png'
-/** A field's checked value, or null; `need` builds the argv only when every named field passes. */
-const need = (fields: DevFields, names: readonly DevField[], build: (values: Record<DevField, string>) => readonly string[]): readonly string[] | null => {
- const values = {} as Record<DevField, string>
-
- for (const name of names) {
- const value = fieldValue(name, fields[name])
-
- if (value === null) return null
- values[name] = value
- }
-
- return build(values)
-}
-
/** A `.rvf` file's branch beside it: `memory.rvf` with label `try` branches to `memory-try.rvf`. */
export const branchPathOf = (path: string, label: string): string => (path.endsWith('.rvf') ? `${path.slice(0, -4)}-${label}.rvf` : `${path}-${label}.rvf`)
@@ -174,17 +168,20 @@ export const DEV: readonly DevEntry[] = [
{ id: 'dt-logs', group: 'maint', name: 'LOGS', about: 'the last 50 log lines', label: 'process logs', cost: 'read', args: fixed(['process', 'logs', '--tail', '50']) },
{ id: 'dt-app-inspect', group: 'maint', name: 'APPLIANCE', about: 'the RVFA header and sections of the path fieldโ€™s .rvf', label: 'appliance inspect', cost: 'read', input: 'path', args: f => need(f, ['path'], v => ['appliance', 'inspect', '-f', v.path, '--json']) },
{ id: 'dt-app-verify', group: 'maint', name: 'APPLIANCE VERIFY', about: 'its integrity (quick, no capability tests)', label: 'appliance verify --quick', cost: 'read', input: 'path', args: f => need(f, ['path'], v => ['appliance', 'verify', '-f', v.path, '--quick']) },
+ ...SANDBOX,
]
/** The confirm-free spec for a local read, the asked one for the rest; null when a field breaks its rule or it is n/a. */
export function devSpec(entry: DevEntry, fields: DevFields): ActionSpec | null {
- const args = entry.na === undefined ? (entry.args?.(fields) ?? null) : null
+ const args = entry.na === undefined ? ((entry.exec ?? entry.args)?.(fields) ?? null) : null
if (args === null) return null
return {
label: entry.label,
- args,
+ args: entry.exec === undefined ? args : [],
+ ...(entry.exec !== undefined && { argv: args, shows: args.join(' ') }),
+ ...(entry.read !== undefined && { read: entry.read }),
expect: entry.cost === 'read' ? 'its output in Dev Tools' : `its result in Dev Tools${entry.note !== undefined ? `; ${entry.note}` : ''}`,
lab: entry.id,
lines: (stdout, stderr) => devLines(entry.id, stdout, stderr),
@@ -197,11 +194,12 @@ export function devSpec(entry: DevEntry, fields: DevFields): ActionSpec | null {
/** Why an entry has nothing to run now, in the footer's words. */
export function devWhy(entry: DevEntry, fields: DevFields): string {
if (entry.na !== undefined) return `n/a: ${entry.na}`
+ const build = entry.exec ?? entry.args
// With every failing field given a passing value it builds: the first failing field it cannot build without is the one to name.
const failing = (Object.keys(SAMPLE) as DevField[]).filter(field => fieldValue(field, fields[field]) === null)
const filled = (except: DevField | null): DevFields => ({ ...fields, ...Object.fromEntries(failing.filter(field => field !== except).map(field => [field, SAMPLE[field]])) })
- const broken = entry.args === undefined || entry.args(filled(null)) === null ? undefined : failing.find(field => entry.args?.(filled(field)) === null)
+ const broken = build === undefined || build(filled(null)) === null ? undefined : failing.find(field => build(filled(field)) === null)
if (broken === undefined) return 'nothing to run'
@@ -210,7 +208,7 @@ export function devWhy(entry: DevEntry, fields: DevFields): string {
}
/** A value each field accepts, to find which field kept an entry from running. */
-const SAMPLE: DevFields = { ref: 'HEAD', path: 'memory.rvf', label: 'l', url: 'https://example.com', target: '@e1', query: 'q', task: 't', cmd: 'c', id: 'i', note: 'n' }
+const SAMPLE: DevFields = { ref: 'HEAD', path: 'memory.rvf', label: 'l', url: 'https://example.com', target: '@e1', query: 'q', task: 't', cmd: 'c', id: 'i', note: 'n', session: 's', send: 'c' }
/**
* Every runnable entry as a palette entry, so `/ruflo run dt-diff HEAD~3` works headless: an entry with an input field
@@ -219,7 +217,7 @@ const SAMPLE: DevFields = { ref: 'HEAD', path: 'memory.rvf', label: 'l', url: 'h
export function devPalette(state: State): PaletteEntry[] {
const fields = state.devtools.fields
- return DEV.filter(entry => entry.na === undefined).map(entry => {
+ return DEV.map(entry => withTmux(entry, state.devtools.tmux)).filter(entry => entry.na === undefined).map(entry => {
const input = entry.input
if (input === undefined) return { id: entry.id, group: 'devtools', label: entry.label, run: { kind: 'spec', spec: devSpec(entry, fields), why: devWhy(entry, fields) } }
@@ -243,8 +241,11 @@ export function devPalette(state: State): PaletteEntry[] {
})
}
+/** The entry as the console can use it now: n/a, with the reason, while the program it needs is known to be missing. */
+export const withTmux = (entry: DevEntry, tmux: State['devtools']['tmux']): DevEntry => (entry.needs === 'tmux' && tmux === 'missing' && entry.na === undefined ? { ...entry, na: 'tmux is not installed on this machine: install it, then open this page again' } : entry)
+
/** Which entry Enter in each field runs; a field with none only keeps its text. */
-const SUBMITS: Partial<Record<DevField, string>> = { task: 'dt-brain', ref: 'dt-diff', path: 'dt-cow-status', url: 'dt-br-open', target: 'dt-br-click', query: 'dt-plug-search', cmd: 'dt-term-exec' }
+const SUBMITS: Partial<Record<DevField, string>> = { task: 'dt-brain', ref: 'dt-diff', path: 'dt-cow-status', session: 'dt-sb-capture', send: 'dt-sb-send', url: 'dt-br-open', target: 'dt-br-click', query: 'dt-plug-search', cmd: 'dt-term-exec' }
export type DevtoolsActions = {
draft: (field: DevField, text: string) => void
diff --git a/plugins/ruflo-console/hooks/gfx/boot.ts b/plugins/ruflo-console/hooks/gfx/boot.ts
index 6c966ba511..b5fcf0e295 100644
--- a/plugins/ruflo-console/hooks/gfx/boot.ts
+++ b/plugins/ruflo-console/hooks/gfx/boot.ts
@@ -50,6 +50,7 @@ export const BOOT_MODULES: readonly { name: string; note: string }[] = [
{ name: 'Skills', note: 'find, add, manage' },
{ name: 'Plugin Catalog', note: 'every plugin, mod and skill' },
{ name: 'Dev Tools', note: 'ADRs, SPARC, tests, git, docs' },
+ { name: 'Sandbox', note: 'tmux, RVF branches, RVM' },
{ name: 'Cost & Budget', note: 'spend, burn, limits' },
{ name: 'Timeline', note: 'who was busy, and when' },
{ name: 'Events', note: 'what changed, live' },
diff --git a/plugins/ruflo-console/hooks/help-docs.ts b/plugins/ruflo-console/hooks/help-docs.ts
index 37a6ec1c43..f479eaabde 100644
--- a/plugins/ruflo-console/hooks/help-docs.ts
+++ b/plugins/ruflo-console/hooks/help-docs.ts
@@ -34,7 +34,7 @@ export const GROUP_BLURB: Record<HelpGroup, string> = {
Work: 'missions, swarms, claims, automation',
Learn: 'learning, memory, vectors, harness',
Safety: 'security, budget, performance',
- Network: 'federation and x.ruv.io',
+ Network: 'federation, x.ruv.io, sandboxes',
Tools: 'plugins, skills, dev tools',
Console: 'settings, updates, commands, fixes',
}
@@ -64,6 +64,7 @@ export const VIEW_TOPIC: Partial<Record<ViewId, string>> = {
xruv: 'xruv',
skills: 'skills',
devtools: 'devtools',
+ sandbox: 'sandbox',
settings: 'settings',
timeline: 'watch',
events: 'watch',
@@ -85,6 +86,7 @@ const SAME: readonly (readonly string[])[] = [
['federation', 'peers', 'peer', 'network', 'share', 'x.ruv.io', 'xruv'],
['mcp', 'connect', 'codex', 'chatgpt', 'grok', 'desktop', 'client', 'register'],
['skill', 'skills', 'playbook'],
+ ['sandbox', 'sandboxes', 'isolated', 'isolate', 'tmux', 'experiment'],
['task', 'tasks', 'claim', 'claims', 'owner', 'board'],
['schedule', 'scheduled', 'loop', 'sentry', 'sentries', 'cron', 'automate', 'automation', 'workflow', 'worker', 'workers'],
]
diff --git a/plugins/ruflo-console/hooks/help-topics-core.ts b/plugins/ruflo-console/hooks/help-topics-core.ts
index c55e5e55d9..e1d0b14806 100644
--- a/plugins/ruflo-console/hooks/help-topics-core.ts
+++ b/plugins/ruflo-console/hooks/help-topics-core.ts
@@ -76,7 +76,7 @@ export const CORE_TOPICS: readonly HelpTopic[] = [
{ text: 'Letters reach the rest: b hive ยท c cost ยท g timeline ยท q approvals ยท e events ยท w x.ruv.io ยท i terminal ยท z skills ยท u security ยท f performance ยท a automation ยท l learning lab ยท v vector lab ยท t self-evolution ยท d dev tools ยท m plugin catalog ยท s settings.' },
{ text: 'p palette ยท x actions for the selection ยท r refresh and replay the intro ยท h help ยท y / n confirm or cancel.' },
{ text: 'j / k move the selection ยท d drill into an agent ยท b back ยท f filters the events page.' },
- { text: 'On the main menu, type a key or a name in the prompt and press Enter. o logs off.' },
+ { text: 'On the main menu, type a key or a name in the prompt and press Enter. o logs off. Sandbox has no key: type sandbox, or find it under NETWORK in the nav.' },
],
tips: ['In a text field, your keys type into the field.'],
related: ['tour', 'headless'],
diff --git a/plugins/ruflo-console/hooks/help-topics-more.ts b/plugins/ruflo-console/hooks/help-topics-more.ts
index fa68a3594d..7ac7fddde8 100644
--- a/plugins/ruflo-console/hooks/help-topics-more.ts
+++ b/plugins/ruflo-console/hooks/help-topics-more.ts
@@ -96,7 +96,7 @@ export const MORE_TOPICS: readonly HelpTopic[] = [
summary: 'the ruflo plugins add skills, agents and commands to Claude Code',
steps: [
{ text: 'Add the ruflo marketplace so Claude Code can install its plugins. It asks first.', go: { start: 'marketplace' } },
- { text: 'Plugins (key 6) is the health of your setup: how fresh the marketplace is, what is installed and loaded.', go: { view: 'plugins' } },
+ { text: 'Plugins (key 6, in the TOOLS group of the nav) is the health of your setup: how fresh the marketplace is, what is installed and loaded.', go: { view: 'plugins' } },
{ text: 'The Plugin Catalog (key m) is where you browse, install, enable, disable, update and remove plugins.', go: { view: 'market' } },
{ text: 'Start a new Claude session after a change so the plugin loads.' },
],
@@ -128,9 +128,27 @@ export const MORE_TOPICS: readonly HelpTopic[] = [
{ text: 'Type in the field above a section, then press its โ–ถ run.' },
{ text: 'A rowโ€™s tag says what it does: $0 reads, wr writes, net uses the network, $$ may spend, del deletes.' },
{ text: 'Anything but a $0 read asks first and shows the exact command.' },
+ { text: 'The agenticow rows (copy-on-write memory branches) are also on the Sandbox page, beside tmux and RVM.', go: { view: 'sandbox' } },
],
+ related: ['sandbox'],
keywords: ['github', 'diff', 'wasm', 'browser', 'review', 'git', 'pr'],
},
+ {
+ id: 'sandbox',
+ title: 'Sandboxes: tmux, RVF and RVM',
+ group: 'Network',
+ summary: 'isolated places to try things, and what each really isolates',
+ steps: [
+ { text: 'Open Sandbox (NETWORK in the nav, or type sandbox at the menu). It has no key.', go: { view: 'sandbox' } },
+ { text: 'tmux: type a name, press NEW, type a command line, press SEND, then CAPTURE to read the screen. LIST shows your ruflo-sb-* sessions; KILL ends one.' },
+ { text: 'RVF: type an .rvf path and a label, BRANCH it, try things on the branch, then ROLLBACK to throw them away or PROMOTE to keep them.' },
+ { text: 'RVM is information only: it enforces what code may do and use, and this console never changes it.' },
+ { text: 'Anything but a $0 read asks first and shows the exact command, as on Dev Tools.', go: { view: 'devtools' }, label: 'Dev Tools' },
+ ],
+ tips: ['A tmux session is a separate shell that runs as you: a place to work apart, not a security boundary.', 'Without tmux installed its rows say n/a.'],
+ related: ['devtools', 'plugins'],
+ keywords: ['sandbox', 'tmux', 'rvf', 'rvm', 'branch', 'isolated', 'copy-on-write', 'experiment', 'try'],
+ },
{
id: 'settings',
title: 'Settings',
diff --git a/plugins/ruflo-console/hooks/nav-state.ts b/plugins/ruflo-console/hooks/nav-state.ts
index c8076938b4..f3598a76ee 100644
--- a/plugins/ruflo-console/hooks/nav-state.ts
+++ b/plugins/ruflo-console/hooks/nav-state.ts
@@ -11,8 +11,8 @@ export const NAV_GROUPS: readonly { title: string; icon: string; rows: readonly
{ title: 'SWARM', icon: '๐Ÿ', rows: [['missions', 'overview', 'swarm', 'hive', 'claims', 'approvals']] },
{ title: 'MIND', icon: '๐Ÿง ', rows: [['learning', 'neural', 'metaharness', 'evolve', 'memory', 'vector']] },
{ title: 'SAFETY', icon: '๐Ÿ›ก๏ธ', rows: [['secure', 'cost', 'perf', 'timeline', 'events']] },
- { title: 'NETWORK', icon: '๐ŸŒ', rows: [['federation', 'xruv', 'plugins', 'skills', 'market']] },
- { title: 'TOOLS', icon: '๐Ÿ› ๏ธ', rows: [['terminal', 'automate', 'devtools', 'settings']] },
+ { title: 'NETWORK', icon: '๐ŸŒ', rows: [['federation', 'xruv', 'sandbox', 'skills', 'market']] },
+ { title: 'TOOLS', icon: '๐Ÿ› ๏ธ', rows: [['terminal', 'automate', 'devtools', 'plugins', 'settings']] },
]
export const groupOf = (view: ViewId): string | null => NAV_GROUPS.find(group => group.rows.some(row => row.includes(view)))?.title ?? null
diff --git a/plugins/ruflo-console/hooks/plugin-map.ts b/plugins/ruflo-console/hooks/plugin-map.ts
index d9e9ab65c8..c0e953c876 100644
--- a/plugins/ruflo-console/hooks/plugin-map.ts
+++ b/plugins/ruflo-console/hooks/plugin-map.ts
@@ -51,7 +51,7 @@ export const PLUGIN_MAP: Readonly<Record<string, PluginHome>> = {
'ruflo-ruos': home('swarm'),
'ruflo-ruvector': home('vector'),
'ruflo-ruvllm': home('neural'),
- 'ruflo-rvf': home('vector'),
+ 'ruflo-rvf': home('sandbox'),
'ruflo-security-audit': home('secure'),
'ruflo-sparc': home('missions'),
'ruflo-swarm': home('swarm'),
diff --git a/plugins/ruflo-console/hooks/sandbox.ts b/plugins/ruflo-console/hooks/sandbox.ts
new file mode 100644
index 0000000000..ac0e63639f
--- /dev/null
+++ b/plugins/ruflo-console/hooks/sandbox.ts
@@ -0,0 +1,84 @@
+/**
+ * The Sandbox page's catalog (ADR-442): isolated places to try things. tmux sessions are real, throwaway work places for agents:
+ * every argv is fixed, runs with no shell, and names a session only as `ruflo-sb-<name>` (the name is checked, the prefix is always
+ * the console's, and `=` makes tmux match exactly), so the console can only ever touch its own. The RVF branches are the Dev Tools
+ * agenticow rows (group `cow`), drawn here too. RVM is information only: no ruflo command or MCP tool reads or changes it. These
+ * entries join `DEV`, so the confirm row, the palette ids and the self-check treat them like every other Dev Tools row. Pure.
+ */
+import { need } from './data/devtools'
+import { plain } from './data/parse'
+import type { Host } from './host'
+import type { DevEntry } from './devtools'
+import type { State } from './state'
+
+export const SANDBOX_PREFIX = 'ruflo-sb-'
+
+/** The sandbox groups: drawn on the Sandbox page, not on Dev Tools. */
+export const SANDBOX_GROUPS = [
+ { id: 'tmux', title: 'tmux sandboxes', right: 'throwaway shells ยท ruflo-sb-* only' },
+ { id: 'rvm', title: 'RVM ยท resource and effect boundary', right: 'information ยท this console never changes it' },
+] as const
+
+const target = (name: string): string => `=${SANDBOX_PREFIX}${name}:`
+const exactName = (name: string): string => `=${SANDBOX_PREFIX}${name}`
+const NOT_SECURITY = 'a tmux session is a separate shell that runs as you: a place to work apart, not a security boundary'
+
+const done = (what: string) => (stdout: string, stderr: string, ok: boolean): string[] => (ok ? [`โœ“ ${what}`] : [`โœ— ${plain(stderr || stdout, 160) || 'tmux refused'}`])
+
+/** `tmux list-sessions` as lines: only ruflo-sb-* sessions, whatever else the server holds; none (or no server yet) says so. */
+export function sandboxLines(stdout: string, stderr: string, ok: boolean): string[] {
+ const rows = stdout.split('\n').map(line => line.split('|')).filter(part => (part[0] ?? '').startsWith(SANDBOX_PREFIX))
+
+ if (rows.length === 0) return [ok || /no server running/.test(stderr) ? `no sandbox sessions yet${ok ? '' : ' (tmux has no server running)'}: NEW starts one` : `โœ— ${plain(stderr, 160) || 'tmux refused'}`]
+
+ return rows.map(([name = '', windows = '?', created = '0']) => {
+ const at = Number(created)
+
+ return `${plain(name.slice(SANDBOX_PREFIX.length), 40)} ยท ${windows} window${windows === '1' ? '' : 's'}${Number.isFinite(at) && at > 0 ? ` ยท started ${new Date(at * 1000).toISOString().slice(0, 16).replace('T', ' ')}Z` : ''}`
+ })
+}
+
+/** The last lines of a captured pane, trailing blanks dropped. */
+export function paneLines(stdout: string, stderr: string, ok: boolean): string[] {
+ if (!ok) return [`โœ— ${plain(stderr, 160) || 'no such sandbox: LIST shows the ones that exist'}`]
+
+ const lines = stdout.split('\n').map(line => plain(line, 160))
+
+ while (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
+
+ return lines.length === 0 ? ['(the pane is empty)'] : lines.slice(-40)
+}
+
+const RVM_NA = 'ruflo has no rvm command or MCP tool (searched the CLI source and tool list). RVM is a separate boundary (ADR-399, ADR-400): code here has authority: none, and nothing in this console can read or change it'
+
+export const SANDBOX: readonly DevEntry[] = [
+ { id: 'dt-sb-list', group: 'tmux', name: 'LIST', about: 'the ruflo-sb-* sessions on this machine', label: 'list tmux sandbox sessions', cost: 'read', needs: 'tmux', exec: () => ['tmux', 'list-sessions', '-F', '#{session_name}|#{session_windows}|#{session_created}', '-f', `#{m:${SANDBOX_PREFIX}*,#{session_name}}`], read: sandboxLines },
+ { id: 'dt-sb-new', group: 'tmux', name: 'NEW', about: 'a detached session ruflo-sb-<name> running your shell', label: 'start a tmux sandbox session', cost: 'writes', needs: 'tmux', input: 'session', exec: f => need(f, ['session'], v => ['tmux', 'new-session', '-d', '-s', `${SANDBOX_PREFIX}${v.session}`]), read: done('session started: SEND types into it'), note: `starts a tmux session; ${NOT_SECURITY}` },
+ { id: 'dt-sb-send', group: 'tmux', name: 'SEND', about: 'type the line into that session and press Enter', label: 'type a command into the tmux sandbox', cost: 'writes', needs: 'tmux', input: 'send', exec: f => need(f, ['session', 'send'], v => ['tmux', 'send-keys', '-t', target(v.session), '-l', v.send, ';', 'send-keys', '-t', target(v.session), 'Enter']), read: done('typed, Enter pressed: CAPTURE shows what it did'), note: 'SHELL COMMAND: runs in that session, as you' },
+ { id: 'dt-sb-capture', group: 'tmux', name: 'CAPTURE', about: 'the last 40 lines on that sessionโ€™s screen', label: 'capture the tmux sandbox screen', cost: 'read', needs: 'tmux', input: 'session', exec: f => need(f, ['session'], v => ['tmux', 'capture-pane', '-p', '-t', target(v.session), '-S', '-40']), read: paneLines },
+ { id: 'dt-sb-kill', group: 'tmux', name: 'KILL', about: 'end that session and everything running in it', label: 'kill the tmux sandbox session', cost: 'deletes', needs: 'tmux', input: 'session', exec: f => need(f, ['session'], v => ['tmux', 'kill-session', '-t', exactName(v.session)]), read: done('session ended'), note: 'DELETES the session and what it runs' },
+
+ { id: 'dt-rvm-status', group: 'rvm', name: 'STATUS', about: 'n/a: no rvm command to read', label: 'rvm status', cost: 'read', na: RVM_NA },
+ { id: 'dt-rvm-ceilings', group: 'rvm', name: 'CEILINGS', about: 'n/a: resource ceilings are enforced by RVM, not shown here', label: 'rvm resource ceilings', cost: 'read', na: RVM_NA },
+ { id: 'dt-rvm-authority', group: 'rvm', name: 'AUTHORITY', about: 'n/a: the console never grants or widens authority', label: 'rvm authority', cost: 'read', na: RVM_NA },
+]
+
+/** What RVM is, per the ADRs, as lines for the page: facts from the repo, nothing the console measured. */
+export const RVM_LINES: readonly string[] = [
+ ' RVM is the privileged effect and resource-ceiling boundary: it decides what code may do and how much it may use.',
+ ' Advisory code (planners, admission decisions) carries authority: none and cannot widen a ceiling (ADR-398, ADR-400).',
+ ' Git subprocesses and sandboxes stay inside RVM and the OS boundary (ADR-399). This console never changes RVM.',
+]
+
+/** Is tmux here? A local, $0 probe when the page opens: a missing tmux makes its rows n/a with the reason. */
+export async function probeTmux(state: State, host: Host): Promise<void> {
+ try {
+ const result = await host.run(['tmux', '-V'], 5_000)
+
+ state.devtools.tmux = result.exitCode === 0 ? 'present' : 'missing'
+ } catch {
+ state.devtools.tmux = 'missing'
+ }
+
+ host.invalidate()
+}
diff --git a/plugins/ruflo-console/hooks/self-check.ts b/plugins/ruflo-console/hooks/self-check.ts
index c57b802539..001dd5b476 100644
--- a/plugins/ruflo-console/hooks/self-check.ts
+++ b/plugins/ruflo-console/hooks/self-check.ts
@@ -22,14 +22,17 @@ export const AREA_VIEW: Record<string, ViewId> = {
Missions: 'missions', Overview: 'overview', Swarm: 'swarm', 'Hive-Mind': 'hive', Claims: 'claims', Approvals: 'approvals', Automation: 'automate',
Learning: 'learning', Neural: 'neural', 'Vector Lab': 'vector', 'Memory Lab': 'memory', MetaHarness: 'metaharness', 'Self-Evolution': 'evolve',
Security: 'secure', Federation: 'federation', 'x.ruv.io': 'xruv', 'Plugins & Mods': 'plugins', Skills: 'skills', 'Plugin Catalog': 'market',
- 'Dev Tools': 'devtools', 'Cost & Budget': 'cost', Timeline: 'timeline', Events: 'events', Performance: 'perf', 'AI Terminal': 'terminal', Settings: 'settings',
+ 'Dev Tools': 'devtools', Sandbox: 'sandbox', 'Cost & Budget': 'cost', Timeline: 'timeline', Events: 'events', Performance: 'perf', 'AI Terminal': 'terminal', Settings: 'settings',
}
+/** Pages with no hotkey on purpose (every letter is taken): reached from the menu, the nav, the palette or by name. */
+const NAMED_ONLY: ReadonlySet<string> = new Set(['sandbox'])
+
export type Registries = { secure: readonly SecEntry[]; secureText: readonly SecText[]; perf: readonly PerfEntry[]; dev: readonly DevEntry[]; lab: readonly LabEntry[] }
export const REGISTRIES: Registries = { secure: SECURE, secureText: SECURE_TEXT, perf: PERF, dev: DEV, lab: LAB }
/** One value per field that its rule accepts, so every runnable Dev Tools row has an input that runs. */
-export const SAMPLE_FIELDS: DevFields = { ref: 'HEAD~1', path: 'memory/sample.rvf', label: 'ckpt-1', url: 'https://example.com', target: '@e1', query: 'auth', task: 'review my pull request', cmd: 'ls', id: 'agent-1', note: 'hello' }
+export const SAMPLE_FIELDS: DevFields = { ref: 'HEAD~1', path: 'memory/sample.rvf', label: 'ckpt-1', url: 'https://example.com', target: '@e1', query: 'auth', task: 'review my pull request', cmd: 'ls', id: 'agent-1', note: 'hello', session: 'demo', send: 'ls -la' }
/** Free text, then an action type (policy-eval takes one): a text verb passes when any of these builds its command. */
const SAMPLE_TEXTS = ['hello world', 'deploy']
@@ -68,18 +71,20 @@ function checkDev(entries: readonly DevEntry[], problems: string[]): number {
continue
}
- if (entry.args === undefined) {
+ const build = entry.exec ?? entry.args
+
+ if (build === undefined) {
problems.push(`${entry.id}: it is neither runnable nor marked n/a`)
continue
}
- const bare = entry.args(emptyFields())
+ const bare = build(emptyFields())
// With no field needed, an empty page must already run; with one, an empty field may be refused, but the sample must run.
if (bare === null && entry.input === undefined) problems.push(`${entry.id}: it names no input field, yet cannot run on an empty page`)
- const sampled = entry.args(SAMPLE_FIELDS)
+ const sampled = build(SAMPLE_FIELDS)
if (!isArgv(sampled)) problems.push(`${entry.id}: no input is accepted, so its button can never run`)
}
@@ -127,7 +132,7 @@ export function selfCheck(registries: Registries = REGISTRIES, views: readonly {
if (view === undefined) problems.push(`${name}: no page is named for this area`)
else {
if (!views.some(entry => entry.id === view)) problems.push(`${name}: its page "${view}" does not exist`)
- if (!views.some(entry => entry.id === view && entry.key !== '')) problems.push(`${name}: its page has no key`)
+ if (!views.some(entry => entry.id === view && (entry.key !== '' || NAMED_ONLY.has(entry.id)))) problems.push(`${name}: its page has no key`)
if (ask[view] === undefined) problems.push(`${name}: its page has no Ask Claude row`)
}
diff --git a/plugins/ruflo-console/hooks/state.ts b/plugins/ruflo-console/hooks/state.ts
index 21e3f543f5..206cdacfd3 100644
--- a/plugins/ruflo-console/hooks/state.ts
+++ b/plugins/ruflo-console/hooks/state.ts
@@ -21,7 +21,7 @@ export type NavStyle = 'auto' | 'icons' | 'brief' | 'full'
export const NAV_STYLES: readonly NavStyle[] = ['auto', 'icons', 'brief', 'full']
export const NAV_KEY = 'nav-style'
-export type ViewId = 'menu' | 'overview' | 'swarm' | 'hive' | 'claims' | 'federation' | 'plugins' | 'learning' | 'metaharness' | 'memory' | 'cost' | 'timeline' | 'approvals' | 'events' | 'missions' | 'xruv' | 'terminal' | 'skills' | 'agent' | 'secure' | 'perf' | 'automate' | 'neural' | 'vector' | 'evolve' | 'devtools' | 'market' | 'settings'
+export type ViewId = 'menu' | 'overview' | 'swarm' | 'hive' | 'claims' | 'federation' | 'plugins' | 'learning' | 'metaharness' | 'memory' | 'cost' | 'timeline' | 'approvals' | 'events' | 'missions' | 'xruv' | 'terminal' | 'skills' | 'agent' | 'secure' | 'perf' | 'automate' | 'neural' | 'vector' | 'evolve' | 'devtools' | 'sandbox' | 'market' | 'settings'
/**
* The views in tab order, each with its hotkey and the inline height it asks for. Digits are the first nine; the three
@@ -60,6 +60,7 @@ export const VIEWS: readonly { id: ViewId; key: string; label: string; short: st
{ id: 'vector', key: 'v', label: 'Vector Lab', short: 'Vec', icon: '๐Ÿงฒ', blurb: 'ruvector: the shared brain, RVF stores, rvlite queries, decompile, workers, edge, hooks intel and your pi identity', rows: 44 },
{ id: 'evolve', key: 't', label: 'Self-Evolution', short: 'Evo', icon: '๐Ÿงฌ', blurb: 'the governed loop: flywheel receipts, ledger, lineage, the policy gate, the witness; Autogenous and rGi', rows: 44 },
{ id: 'devtools', key: 'd', label: 'Dev Tools', short: 'Dev', icon: '๐Ÿ”ง', blurb: 'the integration surface: GitHub, diff analysis, agenticow, WASM, browser, terminal, providers, maintenance', rows: 40 },
+ { id: 'sandbox', key: '', label: 'Sandbox', short: 'Sbx', icon: '๐Ÿงซ', blurb: 'isolated places to try things: tmux sessions, RVF copy-on-write branches, RVM', rows: 40 },
{ id: 'market', key: 'm', label: 'Plugin Catalog', short: 'Cat', icon: '๐Ÿ“ฆ', blurb: 'every ruflo plugin, mod and skill: what it ships, install, enable, disable, update, view and use', rows: 50 },
{ id: 'settings', key: 's', label: 'Settings', short: 'Set', icon: 'โš™๏ธ', blurb: 'simple to advanced settings: plugin options, ruflo config, updates, and the AI terminalโ€™s model and budget, each edited in place', rows: 50 },
]
@@ -284,7 +285,7 @@ export type State = {
/** The Self-Evolution view: the flywheel files as last read, and what its checks answered. */
evolve: EvolveState
/** The Dev Tools view: what is typed in its fields (its runs share the lab result panel, ids dt-*). */
- devtools: { fields: DevFields }
+ devtools: { fields: DevFields; /** Whether tmux is on this machine, from a probe when the Sandbox page opens. */ tmux: 'unknown' | 'present' | 'missing' }
timers: Map<string, Timer>
stats: { renders: number[]; refreshes: number[]; frames: number[] }
}
@@ -350,7 +351,7 @@ export function newState(raw: PluginOptions | undefined): State {
auto: emptyAuto(),
vector: emptyVector(),
evolve: emptyEvolve(),
- devtools: { fields: emptyFields() },
+ devtools: { fields: emptyFields(), tmux: 'unknown' },
timers: new Map(),
stats: { renders: [], refreshes: [], frames: [] },
}
diff --git a/plugins/ruflo-console/hooks/view-open.ts b/plugins/ruflo-console/hooks/view-open.ts
index 5ab3e338d2..e35ee4f726 100644
--- a/plugins/ruflo-console/hooks/view-open.ts
+++ b/plugins/ruflo-console/hooks/view-open.ts
@@ -5,6 +5,7 @@
import { loadEvolve } from './evolve'
import type { Host } from './host'
import { loadCatalog } from './plugin-catalog'
+import { probeTmux } from './sandbox'
import { loadAiPrefs, loadCore, loadPlugin, settingsOf } from './settings'
import { CLI_PREFIXES, type State } from './state'
@@ -18,6 +19,9 @@ export function openLoaders(state: State, host: Host, view: State['view']): void
// Self-Evolution reads ruflo's own flywheel files (local, no CLI run); its checks wait for a click.
if (view === 'evolve') void loadEvolve(state, host)
+ // The Sandbox page asks whether tmux is here (local, $0): without it the tmux rows say n/a.
+ if (view === 'sandbox') void probeTmux(state, host)
+
// The catalog is read from the marketplace clone on disk: local, so opening it is enough.
if (view === 'market') loadCatalog(state, host)
diff --git a/plugins/ruflo-console/hooks/views/devtools.ts b/plugins/ruflo-console/hooks/views/devtools.ts
index 54ae759c47..5f31d93dec 100644
--- a/plugins/ruflo-console/hooks/views/devtools.ts
+++ b/plugins/ruflo-console/hooks/views/devtools.ts
@@ -4,6 +4,7 @@ import type { DevField } from '../data/devtools'
import { DEV, DEV_GROUPS, devSpec, type DevCost, type DevEntry, type DevGroup } from '../devtools'
import { slot } from './attention'
import { ago, button, clip, col, type Ctx, row, section, tagChip, text, THEME } from './common'
+import { SANDBOX_GROUPS } from '../sandbox'
import { spinAt } from '../spinner'
import { sendResultRow } from './secure'
@@ -38,11 +39,15 @@ const FIELDS: Partial<Record<DevGroup, readonly { field: DevField; label: string
{ field: 'id', label: 'id', placeholder: 'a session / agent id (terminal, DAA, managed agents)' },
],
plugins: [{ field: 'query', label: 'search', placeholder: 'words to search the plugin registry (IPFS: asks first)', submit: 'search' }],
+ tmux: [
+ { field: 'session', label: 'name', placeholder: 'a sandbox name: letters, digits _ - (the console adds ruflo-sb-)', submit: 'capture' },
+ { field: 'send', label: 'type', placeholder: 'one command line to type into that session: Enter shows it, then asks before it runs', submit: 'send' },
+ ],
daa: [{ field: 'note', label: 'note', placeholder: 'feedback or knowledge to send (also a managed-agent prompt)' }],
}
/** One dotted-leader row: the cost tag, the name, what it does, and its โ–ธ button; an n/a row says why instead. */
-function entryRow(ctx: Ctx, entry: DevEntry, lead: number): RenderElement {
+export function entryRow(ctx: Ctx, entry: DevEntry, lead: number): RenderElement {
const tag = TAG[entry.cost]
const isNa = entry.na !== undefined
const isBlocked = !isNa && devSpec(entry, ctx.state.devtools.fields) === null
@@ -61,7 +66,7 @@ function entryRow(ctx: Ctx, entry: DevEntry, lead: number): RenderElement {
)
}
-function fieldRows(ctx: Ctx, group: DevGroup): RenderElement[] {
+export function fieldRows(ctx: Ctx, group: DevGroup): RenderElement[] {
const fields = FIELDS[group] ?? []
const Input = ctx.kit.Input
@@ -83,7 +88,7 @@ function fieldRows(ctx: Ctx, group: DevGroup): RenderElement[] {
}
/** The Result section's header: a running run with its seconds and spinner, the last exit, or that nothing ran yet. */
-function resultRight(ctx: Ctx): string {
+export function resultRight(ctx: Ctx): string {
const { state, nowMs } = ctx
const running = state.lab.running?.id.startsWith('dt-') === true ? state.lab.running : null
const result = state.lab.result?.id.startsWith('dt-') === true ? state.lab.result : null
@@ -140,7 +145,8 @@ export function devtoolsView(ctx: Ctx): RenderElement {
const hasRun = state.lab.running?.id.startsWith('dt-') === true || state.lab.result?.id.startsWith('dt-') === true || state.pending !== null
const rows: RenderElement[] = [text(ctx, ' $0 local read, runs at once ยท cpu/wr local work or a write ยท net the network ยท $$ may spend ยท del deletes: each of these asks first', { dimColor: true })]
- DEV_GROUPS.forEach((group, i) => {
+ // The sandbox groups (tmux, RVM) are drawn on the Sandbox page, not here.
+ DEV_GROUPS.filter(group => !SANDBOX_GROUPS.some(sandbox => sandbox.id === group.id)).forEach((group, i) => {
const entries = DEV.filter(candidate => candidate.group === group.id)
// The first group, and every group with a text field, opens: a field folded away could not be typed into, so its runs would refuse.
diff --git a/plugins/ruflo-console/hooks/views/menu.ts b/plugins/ruflo-console/hooks/views/menu.ts
index 25d8ff5c2e..b31b7ef66e 100644
--- a/plugins/ruflo-console/hooks/views/menu.ts
+++ b/plugins/ruflo-console/hooks/views/menu.ts
@@ -45,13 +45,13 @@ export const GROUPS: readonly { title: string; sections: readonly { name: string
{
title: 'NETWORK & EXTEND',
sections: [
- { name: 'network', items: [{ label: 'Federation', go: 'federation' }, { label: 'x.ruv.io Board', go: 'xruv' }] },
- { name: 'plugins', items: [{ label: 'Plugins & Mods', go: 'plugins' }, { label: 'Skills', go: 'skills' }, { label: 'Plugin Catalog', go: 'market' }] },
+ { name: 'network', items: [{ label: 'Federation', go: 'federation' }, { label: 'x.ruv.io Board', go: 'xruv' }, { label: 'Sandbox', go: 'sandbox' }] },
+ { name: 'extend', items: [{ label: 'Skills', go: 'skills' }, { label: 'Plugin Catalog', go: 'market' }] },
],
},
{
title: 'TOOLS',
- sections: [{ name: 'tools', items: [{ label: 'AI Terminal', go: 'terminal' }, { label: 'Automation', go: 'automate' }, { label: 'Dev Tools', go: 'devtools' }, { label: 'Settings', go: 'settings' }, { label: 'Command Palette', go: 'palette' }, { label: 'Help', go: 'help' }, { label: 'Log Off', go: 'close' }] }],
+ sections: [{ name: 'tools', items: [{ label: 'AI Terminal', go: 'terminal' }, { label: 'Automation', go: 'automate' }, { label: 'Dev Tools', go: 'devtools' }, { label: 'Plugins & Mods', go: 'plugins' }, { label: 'Settings', go: 'settings' }, { label: 'Command Palette', go: 'palette' }, { label: 'Help', go: 'help' }, { label: 'Log Off', go: 'close' }] }],
},
]
diff --git a/plugins/ruflo-console/hooks/views/pane.ts b/plugins/ruflo-console/hooks/views/pane.ts
index 94c8e2e14c..b9dae826a9 100644
--- a/plugins/ruflo-console/hooks/views/pane.ts
+++ b/plugins/ruflo-console/hooks/views/pane.ts
@@ -26,6 +26,7 @@ import { evolveResult, evolveView } from './evolve'
import { catalogView } from './plugin-catalog'
import { settingsView } from './settings'
import { devtoolsResult, devtoolsView } from './devtools'
+import { sandboxView } from './sandbox'
import { federationView } from './federation'
import { hiveView } from './hive'
import { learningView } from './learning'
@@ -85,6 +86,7 @@ const BODIES: Record<ViewId, (ctx: Ctx) => RenderElement> = {
vector: vectorView,
evolve: evolveView,
devtools: devtoolsView,
+ sandbox: sandboxView,
market: catalogView,
settings: settingsView,
agent: agentView,
@@ -289,6 +291,7 @@ const RESULT_OF: Partial<Record<ViewId, (ctx: Ctx) => RenderElement[]>> = {
overview: optimizerResult,
metaharness: labResult,
devtools: devtoolsResult,
+ sandbox: devtoolsResult,
vector: vectorResult,
evolve: evolveResult,
secure: secureResult,
diff --git a/plugins/ruflo-console/hooks/views/sandbox.ts b/plugins/ruflo-console/hooks/views/sandbox.ts
new file mode 100644
index 0000000000..7233b16793
--- /dev/null
+++ b/plugins/ruflo-console/hooks/views/sandbox.ts
@@ -0,0 +1,38 @@
+import type { RenderElement } from 'claude-code'
+
+import { DEV, DEV_GROUPS, withTmux, type DevGroup } from '../devtools'
+import { RVM_LINES } from '../sandbox'
+import { col, type Ctx, section, text } from './common'
+import { entryRow, fieldRows, resultRight, devtoolsResult } from './devtools'
+
+/** One section's rows: the entries of a group as Dev Tools draws them, n/a with the reason while tmux is known missing. */
+function rows(ctx: Ctx, group: DevGroup, lead: number): RenderElement[] {
+ return DEV.filter(entry => entry.group === group).map(entry => entryRow(ctx, withTmux(entry, ctx.state.devtools.tmux), lead))
+}
+
+const right = (group: DevGroup): string => DEV_GROUPS.find(entry => entry.id === group)?.right ?? ''
+
+/**
+ * Isolated places to try things, in three sections: tmux sessions (real, throwaway shells the console names `ruflo-sb-*`), RVF
+ * copy-on-write branches (the Dev Tools agenticow rows, the same entries and fields) and RVM (information only). Drawing it runs
+ * nothing; the tmux probe ran when the page opened. The result of the last run shows below, as on Dev Tools.
+ */
+export function sandboxView(ctx: Ctx): RenderElement {
+ const { state } = ctx
+ const lead = Math.max(16, Math.min(24, ctx.columns - 44))
+ const hasRun = state.lab.running?.id.startsWith('dt-') === true || state.lab.result?.id.startsWith('dt-') === true || state.pending !== null
+ const tmuxNote = state.devtools.tmux === 'missing' ? ' tmux is not installed on this machine: its rows are n/a' : ' a tmux session is a separate shell that runs as you: a place to work apart, not a security boundary'
+
+ return col(
+ ctx,
+ [
+ text(ctx, ' isolated places to try things: tmux sessions ยท RVF copy-on-write branches ยท RVM. $0 reads run at once; the rest ask first', { dimColor: true }),
+ ...section(ctx, 'sb-tmux', 'tmux sandboxes', `${DEV.filter(entry => entry.group === 'tmux').length} ยท ${right('tmux')}`, [text(ctx, tmuxNote, { dimColor: true }), ...fieldRows(ctx, 'tmux'), ...rows(ctx, 'tmux', lead)], true),
+ ...section(ctx, 'sb-rvf', 'RVF sandboxes ยท copy-on-write branches', `${DEV.filter(entry => entry.group === 'cow').length} ยท an .rvf file ยท writes ask`, [text(ctx, ' branch it, try things on the branch, then ROLLBACK to throw them away or PROMOTE to keep them (the same rows as Dev Tools)', { dimColor: true }), ...fieldRows(ctx, 'cow'), ...rows(ctx, 'cow', lead)], true),
+ ...section(ctx, 'sb-rvm', 'RVM ยท resource and effect boundary', right('rvm'), [...RVM_LINES.map(line => text(ctx, line, { dimColor: true })), ...rows(ctx, 'rvm', lead)], true),
+ ...section(ctx, 'dt-result', 'Result', resultRight(ctx), devtoolsResult(ctx), hasRun),
+ text(ctx, ' every row is a palette id too: /ruflo run dt-sb-new demo, /ruflo run dt-sb-capture demo', { dimColor: true }),
+ ],
+ 'sandbox',
+ )
+}
diff --git a/plugins/ruflo-console/scripts/smoke.sh b/plugins/ruflo-console/scripts/smoke.sh
index f0b0e9bf1a..22644a8f11 100755
--- a/plugins/ruflo-console/scripts/smoke.sh
+++ b/plugins/ruflo-console/scripts/smoke.sh
@@ -82,7 +82,7 @@ step "15. the live no-spend e2e smoke exists, is executable and skips cleanly wi
if [[ -x "$ROOT/scripts/e2e-smoke.sh" ]] && bash "$ROOT/scripts/e2e-smoke.sh" 2>&1 | grep -q '^SKIP'; then ok; else bad "e2e-smoke.sh"; fi
step "16. every view has a matrix entry and an ask entry"
-if [[ "$(grep -c "{ id: '[a-z]*', key: '[0-9a-z]'" "$ROOT/hooks/state.ts")" -eq "$(grep -cE "^ [a-z]+: \{ default:" "$ROOT/hooks/ask-claude.ts" | awk '{print $1 - 1}')" ]]; then ok; else bad "VIEW_ASK does not cover VIEWS"; fi
+if [[ "$(grep -c "{ id: '[a-z]*', key: '[0-9a-z]*'" "$ROOT/hooks/state.ts")" -eq "$(grep -cE "^ [a-z]+: \{ default:" "$ROOT/hooks/ask-claude.ts" | awk '{print $1 - 1}')" ]]; then ok; else bad "VIEW_ASK does not cover VIEWS"; fi
printf "\n%d passed, %d failed\n" "$PASS" "$FAIL"
[[ $FAIL -eq 0 ]]
diff --git a/plugins/ruflo-console/tests/boot-cyber.spec.ts b/plugins/ruflo-console/tests/boot-cyber.spec.ts
index bba2866a2a..95d43fd11a 100644
--- a/plugins/ruflo-console/tests/boot-cyber.spec.ts
+++ b/plugins/ruflo-console/tests/boot-cyber.spec.ts
@@ -59,7 +59,7 @@ describe('the cyberpunk log', () => {
expect(text).toContain('RUV.NET // RUVECTOR CONSTELLATION')
expect(text).toContain('rUv ยท ruflo v0.26.0 ยท abc123')
expect(text).toContain('ruvector')
- expect(text).toMatch(/\[WARN\] READY ยท 26 of 26 areas verified ยท \d+ stars? dark/)
+ expect(text).toMatch(/\[WARN\] READY ยท 27 of 27 areas verified ยท \d+ stars? dark/)
expect(text).not.toContain('ALL STARS ALIGNED')
})
@@ -76,7 +76,7 @@ describe('the cyberpunk log', () => {
const failed = textOf(bootPicture('p', 90, 6000, 10, 10, rowsFor, failing, bootFacts(lit, '1', '')))
expect(failed).not.toContain('ALL STARS ALIGNED')
- expect(failed).toMatch(/\[FAIL\] READY ยท 25 of 26 areas verified ยท 1 failed/)
+ expect(failed).toMatch(/\[FAIL\] READY ยท 26 of 27 areas verified ยท 1 failed/)
})
it('shows the easter egg only in its window, and it decodes to rUv', () => {
@@ -97,7 +97,7 @@ describe('the cyberpunk log', () => {
it('falls back to the plain log in a narrow or short pane', () => {
const facts = bootFacts(withPlugins([]), '1', '')
- expect(textOf(bootPicture('p', 44, 6000, 10, 10, rowsFor, allOk, facts))).toContain('[ OK ] READY 26 of 26 areas verified')
+ expect(textOf(bootPicture('p', 44, 6000, 10, 10, rowsFor, allOk, facts))).toContain('[ OK ] READY 27 of 27 areas verified')
expect(textOf(bootPicture('p', 90, 6000, 10, 10, BOOT_ROWS + 6, allOk, facts))).not.toContain('RUV.NET')
})
})
diff --git a/plugins/ruflo-console/tests/devtools.spec.ts b/plugins/ruflo-console/tests/devtools.spec.ts
index 3c06851e55..a1583b3de7 100644
--- a/plugins/ruflo-console/tests/devtools.spec.ts
+++ b/plugins/ruflo-console/tests/devtools.spec.ts
@@ -94,7 +94,7 @@ const COMMANDS: Record<string, readonly string[]> = {
'appliance verify': ['-f', '--quick'],
}
-const FULL: DevFields = { ref: 'main..HEAD', path: '.swarm/memory.rvf', label: 'try-1', url: 'https://example.com/a?b=1', target: '@e3', query: 'neural', task: 'review my pull request', cmd: 'git status', id: 'agent-1', note: 'worked well' }
+const FULL: DevFields = { ref: 'main..HEAD', path: '.swarm/memory.rvf', label: 'try-1', url: 'https://example.com/a?b=1', target: '@e3', query: 'neural', task: 'review my pull request', cmd: 'git status', id: 'agent-1', note: 'worked well', session: 'demo', send: 'git status' }
const runnable = DEV.filter(entry => entry.na === undefined)
@@ -134,7 +134,8 @@ describe('the Dev Tools catalog', () => {
const argv = devSpec(entry, FULL)?.args ?? []
expect(argv.some(word => /^(sh|bash|zsh)$/.test(word)), entry.id).toBe(false)
- if (argv[0] === 'mcp') continue
+ // A tmux entry is a fixed command outside ruflo (`exec`): tests/sandbox.spec.ts checks it.
+ if (argv[0] === 'mcp' || entry.exec !== undefined) continue
const name = Object.keys(COMMANDS).find(command => argv.join(' ').startsWith(command))
diff --git a/plugins/ruflo-console/tests/nav.spec.ts b/plugins/ruflo-console/tests/nav.spec.ts
index 2ceeb69f30..bf1fbf6dce 100644
--- a/plugins/ruflo-console/tests/nav.spec.ts
+++ b/plugins/ruflo-console/tests/nav.spec.ts
@@ -6,11 +6,13 @@ import { VIEWS, viewOf } from '../hooks/state'
const RESERVED = ['p', 'x', 'r', 'h', 'j', 'k', 'y', 'n', 'o']
describe('main nav hotkeys', () => {
- it('every view has one, a single digit or lowercase letter, and no two share it', () => {
- const keys = VIEWS.map(view => view.key)
+ it('every view has one (a single digit or lowercase letter) or none (reached by name), and no two share one', () => {
+ // Every letter is a view key or reserved, so Sandbox has no key: it is reached from the menu, the nav or by typing `sandbox`.
+ const keys = VIEWS.map(view => view.key).filter(key => key !== '')
expect(keys.every(key => /^[0-9a-z]$/.test(key))).toBe(true)
expect(new Set(keys).size).toBe(keys.length)
+ expect(VIEWS.filter(view => view.key === '').map(view => view.id)).toEqual(['sandbox'])
})
it('none takes a key the footer, the confirm row, scrolling or the menu prompt owns', () => {
@@ -27,7 +29,7 @@ describe('main nav hotkeys', () => {
it('a view is reached by its key and by its id', () => {
for (const view of VIEWS) {
- expect(viewOf(view.key), view.id).toBe(view.id)
+ if (view.key !== '') expect(viewOf(view.key), view.id).toBe(view.id)
expect(viewOf(view.id), view.id).toBe(view.id)
}
})
diff --git a/plugins/ruflo-console/tests/sandbox.spec.ts b/plugins/ruflo-console/tests/sandbox.spec.ts
new file mode 100644
index 0000000000..f4a5d8680b
--- /dev/null
+++ b/plugins/ruflo-console/tests/sandbox.spec.ts
@@ -0,0 +1,247 @@
+/**
+ * The Sandbox page (ADR-442): Plugins sits in TOOLS and Sandbox in NETWORK, every page in exactly one group; the tmux entries are fixed
+ * argv arrays that can only name ruflo-sb-* sessions, type with -l and never reach a shell; a missing tmux makes the rows n/a; the page
+ * has its three sections; the guide exists and points at real things. Run with
+ * npx vitest run plugins/ruflo-console/tests/sandbox.spec.ts
+ */
+import { describe, expect, it } from 'vitest'
+
+import { emptyFields, fieldValue, type DevFields } from '../hooks/data/devtools'
+import { DEV, DEV_GROUPS, devPalette, devSpec, devWhy, withTmux } from '../hooks/devtools'
+import { topicById } from '../hooks/help-topics'
+import { VIEW_TOPIC } from '../hooks/help-docs'
+import { groupOf, NAV_GROUPS } from '../hooks/nav-state'
+import { paneLines, probeTmux, RVM_LINES, SANDBOX, sandboxLines } from '../hooks/sandbox'
+import { newState, VIEWS } from '../hooks/state'
+import type { Ctx } from '../hooks/views/common'
+import { GROUPS } from '../hooks/views/menu'
+import { sandboxView } from '../hooks/views/sandbox'
+
+const fields = (over: Partial<DevFields>): DevFields => ({ ...emptyFields(), ...over })
+const entry = (id: string) => DEV.find(candidate => candidate.id === id)!
+const argvOf = (id: string, over: Partial<DevFields>) => devSpec(entry(id), fields(over))?.argv ?? null
+
+describe('the nav groups', () => {
+ it('has Plugins in TOOLS and Sandbox in NETWORK; Skills and the Plugin Catalog stay in NETWORK', () => {
+ expect(groupOf('plugins')).toBe('TOOLS')
+ expect(groupOf('sandbox')).toBe('NETWORK')
+ expect(groupOf('skills')).toBe('NETWORK')
+ expect(groupOf('market')).toBe('NETWORK')
+ })
+
+ it('puts every page but the menu in exactly one group, at most six to a row', () => {
+ const all = NAV_GROUPS.flatMap(group => group.rows.flat())
+
+ expect(new Set(all).size).toBe(all.length)
+ expect([...all].sort()).toEqual(VIEWS.filter(view => view.id !== 'menu').map(view => view.id).sort())
+ for (const group of NAV_GROUPS) for (const row of group.rows) expect(row.length).toBeLessThanOrEqual(6)
+ })
+
+ it('draws the same grouping on the main menu: Plugins & Mods on the TOOLS card, Sandbox on NETWORK & EXTEND', () => {
+ const goes = (title: string) => GROUPS.find(group => group.title === title)!.sections.flatMap(section => section.items.map(item => item.go))
+
+ expect(goes('TOOLS')).toContain('plugins')
+ expect(goes('NETWORK & EXTEND')).not.toContain('plugins')
+ expect(goes('NETWORK & EXTEND')).toContain('sandbox')
+ })
+
+ it('gives Sandbox no key, since every letter is a page key or reserved', () => {
+ expect(VIEWS.find(view => view.id === 'sandbox')?.key).toBe('')
+ })
+})
+
+describe('the tmux entries', () => {
+ const tmux = SANDBOX.filter(candidate => candidate.group === 'tmux')
+ const FULL = fields({ session: 'demo', send: 'echo hi; ls' })
+
+ it('are fixed argv arrays that start with tmux, hold no shell, and are the same for the same fields', () => {
+ expect(tmux.map(candidate => candidate.id)).toEqual(['dt-sb-list', 'dt-sb-new', 'dt-sb-send', 'dt-sb-capture', 'dt-sb-kill'])
+
+ for (const candidate of tmux) {
+ const spec = devSpec(candidate, FULL)
+
+ expect(spec?.args, candidate.id).toEqual([])
+ expect(spec?.argv?.[0], candidate.id).toBe('tmux')
+ expect(spec?.argv?.some(word => /^(sh|bash|zsh|-c)$/.test(word)), candidate.id).toBe(false)
+ expect(devSpec(candidate, FULL)?.argv).toEqual(spec?.argv)
+ }
+ })
+
+ it('name a session only as an exact ruflo-sb-<name>, so the console can touch nothing else', () => {
+ expect(argvOf('dt-sb-new', { session: 'demo' })).toEqual(['tmux', 'new-session', '-d', '-s', 'ruflo-sb-demo'])
+ expect(argvOf('dt-sb-kill', { session: 'demo' })).toEqual(['tmux', 'kill-session', '-t', '=ruflo-sb-demo'])
+ expect(argvOf('dt-sb-capture', { session: 'demo' })).toEqual(['tmux', 'capture-pane', '-p', '-t', '=ruflo-sb-demo:', '-S', '-40'])
+
+ for (const id of ['dt-sb-new', 'dt-sb-send', 'dt-sb-capture', 'dt-sb-kill']) {
+ for (const bad of ['', '-x', '_a', 'a b', 'a.b', 'a:b', 'a;b', '../x', 'a'.repeat(41), 'a\nb', '=x', '*']) expect(argvOf(id, { session: bad, send: 'ls' }), `${id} ${bad}`).toBeNull()
+ }
+
+ expect(fieldValue('session', 'a'.repeat(40))).not.toBeNull()
+ expect(fieldValue('session', 'Ab_c-9')).not.toBeNull()
+ })
+
+ it('types with -l then presses Enter as a separate tmux command; the text is one element', () => {
+ const argv = argvOf('dt-sb-send', FULL) ?? []
+
+ expect(argv).toEqual(['tmux', 'send-keys', '-t', '=ruflo-sb-demo:', '-l', 'echo hi; ls', ';', 'send-keys', '-t', '=ruflo-sb-demo:', 'Enter'])
+ expect(argv.indexOf('-l')).toBeLessThan(argv.indexOf('Enter'))
+ })
+
+ it('follows the terminal prose rule for the text, and refuses text ending in ; (tmux would split it into two commands)', () => {
+ for (const bad of ['', ' ', '-rf /', 'a\nb', 'a\u0007b', 'x'.repeat(201), 'ls;']) expect(argvOf('dt-sb-send', fields({ session: 'demo', send: bad })), JSON.stringify(bad)).toBeNull()
+
+ expect(argvOf('dt-sb-send', fields({ session: 'demo', send: 'x'.repeat(200) }))).not.toBeNull()
+ expect(devWhy(entry('dt-sb-send'), fields({ session: 'demo', send: 'ls;' }))).toMatch(/send field.*not ending in ;/)
+ expect(devWhy(entry('dt-sb-new'), fields({}))).toMatch(/session field is empty/)
+ })
+
+ it('tags each row by what it does: read, writes, a SHELL COMMAND, deletes', () => {
+ expect(tmux.map(candidate => candidate.cost)).toEqual(['read', 'writes', 'writes', 'read', 'deletes'])
+ expect(devSpec(entry('dt-sb-send'), FULL)?.note).toMatch(/SHELL COMMAND/)
+ expect(devSpec(entry('dt-sb-kill'), FULL)?.note).toMatch(/DELETES/)
+ expect(devSpec(entry('dt-sb-list'), FULL)?.isReadOnly).toBe(true)
+ expect(devSpec(entry('dt-sb-send'), FULL)?.isReadOnly).toBeUndefined()
+ })
+
+ it('go n/a with the reason when tmux is missing, and out of the palette; unknown counts as present', () => {
+ const state = newState({})
+ const ids = () => devPalette(state).map(candidate => candidate.id)
+
+ expect(ids()).toContain('dt-sb-new')
+ state.devtools.tmux = 'missing'
+ expect(ids()).not.toContain('dt-sb-new')
+ expect(ids()).toContain('dt-cow-status')
+
+ for (const candidate of tmux) {
+ const na = withTmux(candidate, 'missing')
+
+ expect(devSpec(na, FULL), candidate.id).toBeNull()
+ expect(devWhy(na, FULL), candidate.id).toMatch(/^n\/a: tmux is not installed/)
+ }
+ })
+
+ it('probes tmux once when the page opens: present on exit 0, missing on a failure or a throw', async () => {
+ const run = async (result: () => Promise<{ exitCode: number }>) => {
+ const state = newState({})
+ const host = { run: result, invalidate: () => undefined }
+
+ await probeTmux(state, host as never)
+
+ return state.devtools.tmux
+ }
+
+ expect(await run(async () => ({ exitCode: 0 }))).toBe('present')
+ expect(await run(async () => ({ exitCode: 127 }))).toBe('missing')
+ expect(await run(() => Promise.reject(new Error('ENOENT')))).toBe('missing')
+ })
+
+ it('lists only ruflo-sb-* sessions, says so when none, and reads a pane without trailing blanks', () => {
+ const out = 'work|2|1791089365\nruflo-sb-demo|1|1791089365\nother|1|1\nruflo-sb-two|3|1791089365\n'
+
+ expect(sandboxLines(out, '', true)).toEqual(['demo ยท 1 window ยท started 2026-10-04 04:49Z', 'two ยท 3 windows ยท started 2026-10-04 04:49Z'])
+ expect(sandboxLines('work|1|1\n', '', true)[0]).toMatch(/no sandbox sessions yet/)
+ expect(sandboxLines('', 'no server running on /tmp/tmux-1000/default', false)[0]).toMatch(/no sandbox sessions yet \(tmux has no server running\)/)
+ expect(paneLines('$ ls\nfile\n\n\n', '', true)).toEqual(['$ ls', 'file'])
+ expect(paneLines('', "can't find session: ruflo-sb-x", false)[0]).toMatch(/^โœ—/)
+ })
+})
+
+describe('the RVF and RVM sections', () => {
+ it('RVF reuses the Dev Tools agenticow rows: the cow group is still there and is the same entries', () => {
+ expect(DEV.filter(candidate => candidate.group === 'cow').map(candidate => candidate.id)).toEqual(expect.arrayContaining(['dt-cow-status', 'dt-cow-diff', 'dt-cow-lineage', 'dt-cow-checkpoint', 'dt-cow-branch', 'dt-cow-rollback', 'dt-cow-promote']))
+ })
+
+ it('RVM is information only: every row is n/a with the reason, and the lines cite what the ADRs say', () => {
+ const rvm = SANDBOX.filter(candidate => candidate.group === 'rvm')
+
+ expect(rvm.length).toBeGreaterThan(0)
+
+ for (const candidate of rvm) {
+ expect(candidate.na, candidate.id).toMatch(/no rvm command or MCP tool/)
+ expect(devSpec(candidate, fields({})), candidate.id).toBeNull()
+ }
+
+ expect(RVM_LINES.join(' ')).toMatch(/authority: none/)
+ expect(RVM_LINES.join(' ')).toMatch(/never changes RVM/)
+ expect(DEV_GROUPS.map(group => group.id)).toEqual(expect.arrayContaining(['tmux', 'rvm']))
+ })
+})
+
+type El = { props: Record<string, unknown> }
+
+describe('the page', () => {
+ const kit = { Box: (props: Record<string, unknown>): El => ({ props }), Text: (props: Record<string, unknown>): El => ({ props }), Button: (props: Record<string, unknown>): El => ({ props }), Input: (props: Record<string, unknown>): El => ({ props }) }
+ const flat = (el: unknown): El[] => {
+ const node = el as El
+
+ if (typeof node !== 'object' || node === null) return []
+
+ const kids = node.props.children
+
+ return [node, ...(Array.isArray(kids) ? kids.flatMap(flat) : typeof kids === 'object' ? flat(kids) : [])]
+ }
+ const draw = (tmux: 'unknown' | 'present' | 'missing' = 'present') => {
+ const state = newState({})
+
+ state.view = 'sandbox'
+ state.devtools.tmux = tmux
+
+ return flat(sandboxView({ kit, state, nowMs: Date.now(), columns: 110, pictures: new Map(), act: new Proxy({}, { get: () => () => undefined }) as never, cards: true } as unknown as Ctx))
+ }
+ const words = (nodes: El[]): string => nodes.map(node => String(node.props.children ?? node.props.label ?? node.props.title ?? '')).join('\n')
+
+ it('has the three sections, the tmux fields and the rows with their tags, and says tmux is not a security boundary', () => {
+ const nodes = draw()
+ const text = words(nodes)
+
+ expect(text).toMatch(/tmux sandboxes/)
+ expect(text).toMatch(/RVF sandboxes/)
+ expect(text).toMatch(/RVM/)
+ expect(text).toMatch(/not a security boundary/)
+ expect(text).toMatch(/ROLLBACK to throw them away or PROMOTE to keep them/)
+ expect(text).toMatch(/never changes RVM/)
+ expect(nodes.filter(node => typeof node.props.key === 'string' && /^dt-(sb|cow|rvm)-/.test(node.props.key as string) === false && String(node.props.key).startsWith('dt-field-tmux-')).map(node => node.props.key)).toEqual(['dt-field-tmux-session', 'dt-field-tmux-send'])
+ expect(nodes.some(node => node.props.key === 'dt-sb-send')).toBe(true)
+ expect(nodes.some(node => node.props.key === 'dt-cow-branch')).toBe(true)
+ expect(text).toMatch(/\$0/)
+ expect(text).toMatch(/del/)
+ })
+
+ it('says n/a with the reason on the tmux rows when tmux is missing, and no button for them', () => {
+ const nodes = draw('missing')
+
+ expect(words(nodes)).toMatch(/tmux is not installed on this machine/)
+ expect(nodes.some(node => node.props.key === 'dt-sb-send')).toBe(false)
+ expect(nodes.some(node => node.props.key === 'dt-cow-branch')).toBe(true)
+ expect(nodes.some(node => node.props.key === 'dt-rvm-status')).toBe(false)
+ })
+})
+
+describe('the guide', () => {
+ it('exists, is the one help opens from the page, and points at pages that exist', () => {
+ const topic = topicById('sandbox')!
+ const views = new Set<string>(VIEWS.map(view => view.id))
+
+ expect(VIEW_TOPIC.sandbox).toBe('sandbox')
+ expect(topic.group).toBe('Network')
+ expect(topic.related).toContain('devtools')
+
+ for (const step of topic.steps) if (step.go !== undefined && 'view' in step.go) expect(views.has(step.go.view)).toBe(true)
+
+ const text = topic.steps.map(step => step.text).join(' ')
+
+ expect(text).toMatch(/NEW/)
+ expect(text).toMatch(/SEND/)
+ expect(text).toMatch(/BRANCH/)
+ expect(text).toMatch(/ROLLBACK/)
+ expect(text).toMatch(/PROMOTE/)
+ expect(text).toMatch(/RVM/)
+ expect(topic.tips?.join(' ')).toMatch(/not a security boundary/)
+ })
+
+ it('says where Plugins and Sandbox live in the guides that name them', () => {
+ expect(topicById('plugins')!.steps.map(step => step.text).join(' ')).toMatch(/TOOLS group of the nav/)
+ expect(topicById('keys')!.steps.map(step => step.text).join(' ')).toMatch(/Sandbox has no key/)
+ expect(topicById('devtools')!.steps.map(step => step.text).join(' ')).toMatch(/Sandbox page/)
+ })
+})
diff --git a/plugins/ruflo-console/tests/sweep.test.ts b/plugins/ruflo-console/tests/sweep.test.ts
index bd95fd3590..c1b6203e38 100644
--- a/plugins/ruflo-console/tests/sweep.test.ts
+++ b/plugins/ruflo-console/tests/sweep.test.ts
@@ -4,7 +4,7 @@ import { RUFLO_FILES } from './fixtures/ruflo-run'
import { cliAnswer, command, elementsOf, keyOf, paneAt, PLUGIN, SESSION, textOf, worldOf } from './fixtures/world'
/** Every area, by the name `/ruflo <name>` takes. */
-const VIEWS = ['overview', 'swarm', 'hive', 'claims', 'federation', 'plugins', 'learning', 'metaharness', 'memory', 'cost', 'timeline', 'approvals', 'events', 'missions', 'xruv', 'skills', 'secure', 'perf', 'automate', 'neural', 'vector', 'evolve', 'devtools', 'market', 'settings']
+const VIEWS = ['overview', 'swarm', 'hive', 'claims', 'federation', 'plugins', 'learning', 'metaharness', 'memory', 'cost', 'timeline', 'approvals', 'events', 'missions', 'xruv', 'skills', 'secure', 'perf', 'automate', 'neural', 'vector', 'evolve', 'devtools', 'sandbox', 'market', 'settings']
/** Buttons that only move the cursor inside a list that has nothing to move over in the fixture world. */
const SCROLL = /^(prev|next|up|down|older|newer|page|older-|newer-|refresh|close|task-next|approve-1|net-|ev-kind-all|tl-range-|sk-scope-project|evolve-reread|xr-(name|about)-|cat-load|cat-reload|st-name-|st-reload|st-level-|nav-style-|mc-tab-|mc-profile-|mc-rigor-|sec-)/i
diff --git a/v3/docs/adr/ADR-442-console-sandbox-page-and-plugins-in-tools.md b/v3/docs/adr/ADR-442-console-sandbox-page-and-plugins-in-tools.md
new file mode 100644
index 0000000000..a5efe91779
--- /dev/null
+++ b/v3/docs/adr/ADR-442-console-sandbox-page-and-plugins-in-tools.md
@@ -0,0 +1,27 @@
+# ADR 442: A Sandbox page in the console, and Plugins moves to TOOLS
+
+Status: Proposed
+
+Date: 2026 10 04
+
+Scope: `plugins/ruflo-console`: `hooks/sandbox.ts` (new), `hooks/views/sandbox.ts` (new), `hooks/devtools.ts`, `hooks/data/devtools.ts`, `hooks/nav-state.ts`, `hooks/views/menu.ts`, `hooks/state.ts`, `hooks/view-open.ts`, `hooks/help-*.ts`, `hooks/plugin-map.ts`.
+
+Supersedes the grouping lines of ADR-430 (menu design) and ADR-424 (nav) only where they place Plugins in NETWORK.
+
+## 1. Decision
+
+1. **Plugins moves to TOOLS** (nav group and main-menu card). Skills and the Plugin Catalog stay in NETWORK & EXTEND: no test needs them to follow, and the catalog is the install surface for what Skills and Plugins show.
+2. **A new `sandbox` page** sits in NETWORK: isolated places to try things. It reuses the Dev Tools machinery (entries with cost tags, fields, the ask-first runner, `devSpec`, the palette ids `dt-*`), so the confirm row, the result panel, `/ruflo run` and the self-check treat its rows like any other.
+ - **tmux sandboxes**: real, throwaway tmux sessions. LIST (read, only `ruflo-sb-*`), NEW, SEND (asks, a SHELL COMMAND), CAPTURE (read), KILL (asks, `del`). Every argv is a fixed array, run with no shell. The name field is `^[A-Za-z0-9][A-Za-z0-9_-]{0,39}$`; the console always prefixes `ruflo-sb-` and targets with `=` (exact match), so it can only touch its own sessions (`=ruflo-sb-a:` never reaches `ruflo-sb-ab`). SEND is `send-keys -t <t> -l <text> ; send-keys -t <t> Enter` as one argv: `-l` types the text literally, Enter is its own tmux command. The text follows the terminal `cmd` prose rule (no leading `-`, no control characters, at most 200) and may not end in `;`, because tmux splits an argument ending in a semicolon into two commands. If tmux is missing (a `tmux -V` probe when the page opens) its rows are n/a with the reason.
+ - **RVF sandboxes**: the Dev Tools agenticow rows (`cow`: status, diff, lineage, checkpoint, branch, rollback, promote), drawn on both pages from the same entries and fields. Branch, try, then rollback or promote.
+ - **RVM**: information only. A search of `v3/@claude-flow/cli/src`, the plugins and the ruflo MCP tool list found no rvm command or tool; ADR-398, ADR-399 and ADR-400 describe RVM as the privileged effect and resource-ceiling boundary, with `authority: none` for advisory code. The rows are n/a with that reason. The console never grants, widens or changes RVM authority.
+3. **Sandbox has no hotkey.** Every letter is a page key or reserved (`p x r h j k y n o`), so `key` is `''`: the page is reached from the menu, the nav, the palette or by typing `sandbox` (the Skills page precedent). `tests/nav.spec.ts` and smoke step 16 accept an empty key.
+4. `ruflo-rvf` has Sandbox as its home page (its Launch row appears there). `ruflo-ruos` stays with Swarm.
+
+## 2. Honest limits
+
+A tmux session is a separate shell that runs as the user. It is a place to work apart, not a security boundary, and the page and the guide say so. Only RVM, the OS and the host decide what code may do.
+
+## 3. Verification
+
+`tests/sandbox.spec.ts` pins the grouping (every page in exactly one group), the tmux argv (fixed, prefixed, validated, `-l`, no shell, n/a without tmux), the page text and the guide. The tmux argv forms were also run against a real tmux 3.4 (exact targeting, `-f` filter, literal text with `;` inside, Enter as its own command). Not verified: tmux versions other than 3.4, and an installed ruflo CLI's `--help` (not installed in the build environment).