Slash Commands

REPL slash commands are registered in apps/agent/src/gateway/repl-commands.ts and surfaced through a ReplCommand registry that /help reads to render its catalog. The registry is the single source of truth. This page mirrors it.

Anything typed in the REPL that does not start with / is forwarded to the agent as a natural-language prompt.

Naming convention

Command names are flat, lowercase, hyphen-separated tokens (^/[a-z0-9]+(-[a-z0-9]+)*$). The secondary action is encoded in the name with a hyphen, never typed as a space-separated sub-action.

• /workflow-new, /workflow-run, /autopilot-new, /autopilot-pause, /strategy-deploy, /agent-run.
• Single-word names are reserved for list / navigation verbs: /autopilot, /watchlist, /markets, /profile.
• A trailing argument may be a value (/strategy-deploy <id>, /deposit <crypto|card>). It is never an action verb: use /agent-run, not /agents run.
• View toggles (/context) stay single-word.

This is the standard for new commands and the migration target for existing ones. The capability-unification work moves both surfaces onto one shared CapabilityDescriptor list (packages/types/src/capabilities.ts); until then the web set still mirrors the REPL (see the next section). Legacy space sub-action forms (for example /agents create) and the /? help alias are unchanged for now; the rollout adds the hyphenated commands and then keeps the old spellings only as deprecated parse shims hidden from /help.

Two slash-command surfaces

The web UI ships an independent slash-command registry at apps/web-ui/src/lib/slash-commands.ts. It is not generated from or kept identical to the REPL registry — the two evolve separately because REPL and web UI have different capabilities. The web set is a smaller, curated subset of "prompt shortcuts" and "skill convergence" templates with four dispatch kinds:

• pipeline — bypasses the normal chat flow. /deep-research runs the server pipeline on /chat; /institution navigates to /institution?send=… where the route wraps the first turn into minara_institution_analyze.
• skill-converge — rewrites the typed slash into a templated prompt that pushes the LLM toward a specific tool. The web templates are copied verbatim from the REPL versions in repl-commands-minara.ts so behavior stays in lockstep. Each entry has a restPolicy: required aborts on empty args, forbidden aborts on extra args, optional-context appends free text as an addendum.
• route — calls react-router's navigate(path) for nav shortcuts like /preferences, /autopilot, /skills, /profile. The REPL's same-name commands do their own functional work in the terminal (list, show, toggle) and are unchanged by the web dispatcher.
• passthrough — recognized slash command but no rewrite; the raw text is sent to the agent as ordinary chat.

The dispatcher lives at apps/web-ui/src/lib/slash-command-dispatch.ts. Web UI surfaces (chat input picker, command omnibox at Cmd/Ctrl+K, and recent-commands recall) all share the same registry, so adding an entry once exposes it everywhere.

The rest of this page documents the REPL surface.

Interactive argument prompting

Every command with required positional arguments walks you through the missing fields step-by-step instead of erroring. Type a bare command and the REPL will ask for each required field in turn, validate your answer, and let you fix a bad input without retyping the whole line.

you> /swap
› Amount (number or 'all'): 0.5
› From token (e.g. USDC): usdc
› To token (e.g. ETH): eth

Rules of thumb:

• Only required args are prompted. Optional trailing args (e.g. [chain] for /swap) stay positional — pass them on the command line if you need them.
• Invalid values re-prompt just the bad field. If you type /swap abc USDC ETH, only Amount is re-prompted. Your already- valid USDC/ETH are kept.
• Three empty answers in a row cancels with × cancelled.
• /close and /cancel render a live picker. Typing a bare /close fetches your open perps positions and shows a numbered list — reply with an index, the token symbol, or a/all.
• HTTP gateway is unchanged. Non-interactive surfaces still receive the classic Usage: ... error when required args are missing — prompting only kicks in when there's a real TTY.

Helpers live in apps/agent/src/gateway/repl-prompts.ts (collectArgs, pickFromList). See Conventions §6.

Keyboard shortcuts

Two input overlays layer on top of readline while the REPL is at the prompt. Both are no-ops on non-TTY stdin (CI, pipes, the HTTP gateway) and never interfere with the slash-command autocomplete dropdown — if the dropdown is already visible (you're mid-/ prefix), the hotkeys below defer to it.

Ctrl+R — reverse history search

Opens a one-line overlay below the prompt showing the most recent history entry that contains your query:

(reverse-i-search) 'swap': /swap AAPL USD

• Type to narrow the query; matches filter in real time.
• Press Ctrl+R again to jump to the next-older match.
• Enter commits the current match to the input line (not auto-submitted — you can keep editing).
• Esc cancels. If the query has no match, the overlay shows (failed reverse-i-search) 'xyz': and Enter also cancels.
• Printable keys extend the query; Backspace trims it. Arrow keys and other navigation are consumed silently so they don't abort the search unexpectedly.

Ctrl+P — command palette

Opens a searchable dropdown of every registered slash command:

palette: 'help'
  ┌───────────────────────────────────────────────────────┐
  │ > /help        Show every registered command          │
  │   /history     Dump recent conversation history       │
  └───────────────────────────────────────────────────────┘

• Type to fuzzy-match against command name, aliases, and description (subsequence match — all query chars must appear in order, case- insensitive, with exact-prefix name hits ranked first).
• ↑/↓ (or j/k when the query is empty) move the pointer.
• Enter commits /<command> with a trailing space to the input line so you can keep typing arguments.
• Esc cancels.

Session control

/help

Show the categorized catalog of every registered command.

/help

/quit / /exit

Gracefully shut down the REPL. Flushes the audit log and closes the SQLite connection.

/clear

Clear conversation history only. The skill session (currently active skills, risk ceiling, pending confirmations) is preserved. The underlying persisted session is untouched — only the on-screen view is cleared.

/new / /reset

Start a fresh chat session: a new persisted session is created, the conversation history and skill session are reset, and later turns record into the new session. Useful when switching tasks mid-session.

/resume [n]

Resume a past CLI chat session. With a number n, loads that entry from the list directly; with no argument, opens a picker of recent CLI sessions (newest first, showing title, age, and message count).

/stop

Cancel the currently-running agent turn. Aborts the in-flight LLM HTTP request mid-stream via an AbortController. The turn is marked aborted in the audit log.

/retry

Re-run the previous user message. Pops the last assistant turn from history and invokes the agent loop with the same prompt.

/model [<model>]

Show or change the active LLM model. Without an argument, prints the current model. With an argument, persists the choice to the model section of ~/.minara/settings.json so the next boot picks it up.

/model
/model claude-sonnet-4-6

/theme [<name>|reset]

Switch the REPL colour theme. Without an argument, opens an interactive picker that previews each palette with a live swatch; arrow keys pick, Enter confirms. /theme <name> sets directly; /theme reset restores the default (minara).

/theme
/theme blade-runner
/theme reset

Available themes:

• minara — default, editorial-fintech brand palette (256-color)
• hermes-legacy — 8-color fallback for older terminals
• blade-runner — amber + neon pink
• fsociety — all-green hacker aesthetic
• digital-soul — purple + pink

The active choice persists to $MINARA_DATA_DIR/ui-theme.json and is restored on the next boot. On terminals that don't advertise 256-color support (COLORTERM unset and TERM missing 256color), rendering is forced to hermes-legacy with a one-line warning — the user's pick is still remembered so upgrading to a capable terminal restores it automatically.

/permission [ask|smart|auto|full|reset]

Show or switch the permission mode for the current REPL session. Without an argument, lists the four modes and marks the active one. /permission reset drops back to the saved preferences.

/permission
/permission smart
/permission reset

The choice is scoped to the running session and is never written to disk, so a restart returns to the saved preferences (safety.autoReview and safety.skipPermissions, whose defaults come from MINARA_AUTO_REVIEW and MINARA_DANGEROUSLY_SKIP_PERMISSIONS). Those preferences are critical-risk writes with their own unlock step; a session switch deliberately does not substitute for it. The web UI exposes the same four modes in the chat permission menu.

/connect [<platform>] [--test|--remove]

Connect, test, or remove an outbound messaging platform. Mirrors the minara auth messaging CLI subcommand but lives inside the REPL so you don't have to exit to add a credential. Persists to the messaging slot of ~/.minara/credentials.json (mode 0600); the running agent hot-reloads the gateway map so workflows can use the new platform on the next dispatch.

/connect                    # numbered list of all 7 providers + status
/connect telegram           # interactive credential entry
/connect slack --test       # send a test ping to verify the connection
/connect telegram --remove  # strip every credential field for the platform

Supported platforms: telegram, slack, discord, whatsapp, signal, email, home_assistant.

During interactive entry:

• Required fields require a non-empty value (3 retries before cancel).
• Optional fields skip immediately on blank.
• Re-config: fields that already have a value show (currently set, blank to keep). To explicitly clear an optional field, use /connect <platform> --remove first to wipe everything, then re-enter the values you want.

Token typing is currently visible on screen via the slash command (the CLI subcommand minara auth messaging add masks tokens). For sensitive credentials, prefer the CLI subcommand or set the env vars in your shell rc.

/goal [goal text]

Set a standing goal for the session and start working on it immediately. After every turn an LLM judge inspects the agent's reply; while the verdict is "not done" the loop auto-injects a continuation prompt and runs another turn — until the judge confirms completion, the turn budget runs out (default 20, GOAL_MAX_TURNS), or you pause. Bare /goal prints the goal's status: text, state, turns used, last verdict, and criteria.

Continuation turns are ordinary turns: fund-moving confirmations still fire, and /stop (or Ctrl+C) pauses the goal.

/goal port the RSI strategy and get the backtest passing
/goal

/goal-add <criterion>

Add an acceptance criterion to the standing goal mid-loop. The judge requires evidence for every criterion before declaring the goal done, and continuation prompts list them.

/goal-drop <n>

Remove acceptance criterion n (1-based, as numbered by /goal).

/goal-pause

Pause automatic continuation. The goal keeps its state and can be resumed later — including after a REPL restart.

/goal-resume

Resume a paused goal. Resets the turn budget and the judge's parse-failure counter, then kicks off a continuation turn.

/goal-clear

Clear the standing goal. Terminal: set a new one with /goal <text>.

/loop [goal text]

Start an autonomous loop toward a goal, guarded by a brake set and a pluggable verifier chain. Like /goal, the loop runs continuation turns until it is satisfied or a brake fires. Unlike /goal, every turn is adjudicated by a chain of verifiers (the "checkers"), and the loop stops on the first budget it exhausts.

/loop add a unit test for the parser and get the suite green --checker command:{"cmd":"pnpm test:unit"}

Usage:

/loop <goal> [--max-turns N] [--budget-tokens N] [--budget-seconds N] [--budget-usd N] [--checker <kind[:json]>]...

Brakes (the loop pauses or wraps up when any one is hit):

• --max-turns N — turn budget. Default 20.
• --budget-tokens N — cumulative token budget across the loop.
• --budget-seconds N — wall-clock budget.
• --budget-usd N — estimated cost budget.
• No-progress guard — if the same tool runs with the same arguments for several turns running, the loop pauses instead of spinning.

Verifiers (--checker, repeatable; defaults to judge when none are given):

• judge — the completion judge: decides whether the goal is done.
• llm — an independent reviewer prompted to find blocking defects. Optional {"criteria":"..."} adds extra review criteria.
• command:{"cmd":"..."} — runs a deterministic command (typecheck / test / lint) through the same guard and sandbox the terminal tool uses; a non-zero exit feeds its output back as defects to fix.
• threshold:{"source":"assistant_json","path":"metrics.sharpe","op":">","value":1.5} — asserts a numeric value read by dotted path from the turn's JSON, a named tool result, or a sandbox file.

When a verifier rejects a turn, its defects are reconstructed into the next continuation prompt, so the agent works on the specific problems rather than a raw error dump. Bare /loop is not a status command — use /loop-status.

/loop-status

Show the current loop's goal, status, turns used, token usage against budget, and the active verifier chain.

/loop-pause

Pause the loop. State is kept and can be resumed.

/loop-resume

Resume a paused loop. Resets the turn, token, and time budgets, then runs a continuation turn.

/loop-stop

Stop and clear the loop. Terminal: start a new one with /loop <text>.

/loop-checker <add|drop|list>

Manage the verifier chain on the current loop without restarting it.

/loop-checker add command:{"cmd":"pnpm typecheck"}
/loop-checker drop 2
/loop-checker list

Usage:

/loop-checker add <kind[:json]> | drop <n> | list

/loop-schedule <goal> --every <seconds>

Run a loop unattended on a cron interval. Each firing runs one turn, adjudicates it through the loop's verifier chain, and either continues on the next interval or, on a terminal decision (done, budget reached, or paused), optionally delivers a summary and stops the schedule.

/loop-schedule watch the BTC funding rate and flag regime shifts --every 3600 --deliver telegram

Usage:

/loop-schedule <goal> --every <seconds> [--deliver <provider>] [--max-turns N] [--budget-tokens N] [--budget-seconds N] [--budget-usd N] [--checker <kind[:json]>]...

--every is in seconds (minimum 30). --deliver <provider> names a configured messaging provider (Telegram, Slack, email, …) to send the final summary to. The brake and verifier flags match /loop. Scheduled turns are autonomous: fund-moving calls need an author-time consent grant, since no one is at the prompt to confirm them.

Agent control

/history [N]

Print the last N entries of conversation history with role and content preview. Default N=10.

/history
/history 25

/profile [show | set <tag> <value> | clear <tag> | prompt [text|clear] | refresh [dim]]

View or edit personalization (financial profile, user tags, custom prompt). Bare /profile (or /profile show) prints the snapshot. The write subcommands accept either canonical tag names ("Risk Profile") or slugs (risk-profile). When run without args in interactive mode, each subcommand falls back to a picker.

/profile                               # snapshot
/profile set risk-profile Conservative # set a tag
/profile clear risk-profile            # explicitly clear a tag (source=user)
/profile prompt "Reply concisely."     # set custom prompt
/profile prompt clear                  # clear custom prompt
/profile refresh                       # force-rebuild all dimensions
/profile refresh trading_summary       # force-rebuild one dimension

All /profile set and /profile clear writes are recorded with source: "user", which beats both learned_preference (preference-system bridge writes) and inferred (autoscan rebuild) under the three-tier precedence rule. The snapshot also surfaces a hint when one or more learned preferences are pending approval — type /preferences pending to review them.

refresh [trading_summary | tags | memories | all] force-rebuilds the targeted dimension(s) immediately, bypassing the normal threshold + min-interval gates used by the event-driven path. Useful after you make a large change (import new wallets, set a hard constraint) and want it reflected in the next turn's system prompt without waiting.

The forced refresh path also runs MinaraHistorySync.runOnce() before the rebuild, pulling fresh perps fills (per sub-wallet) and spot activities from Minara's /v1/perp-wallets/fills and /v1/tx/cross-chain/activities endpoints into the local mirror tables. That way the rebuilt platform_wallet_summary reflects whatever you just did on Minara web or mobile, not just the last cached state. Routine refreshes (no force) rely on the syncer's own 5-minute throttle and the safety-net tick instead.

/remember <content>

Save a fact to long-term personalization memory immediately, and force a tags rebuild so the new fact shows up in the next turn's snapshot without waiting for the debounce window.

/remember I only hold BTC and ETH spot positions
/remember Never trade meme coins or leverage above 3x

Statements are written with category='personalization' and subcategory='preference'. Max length is the maxMemoryStatementLen config (default 120 characters) — longer input is rejected with a usage error. For unconstrained fact extraction via the LLM (mem0-v3-style), let the event-driven rebuilder run on its own or call /profile refresh memories.

/preferences [list|pending|show|approve|reject|deprecate|undo] (alias /prefs)

Manage learned preferences mined from your conversation by the preference-evolution system (Financial Auto-Memory). M2 added approve / reject / deprecate; M3 adds undo + the keyword scanner + tool-level enforcement.

/preferences pending           # awaiting approval
/preferences list              # all preferences
/preferences list active       # filter by state
/preferences show <id>         # full detail (interactive picker if id omitted)
/preferences approve <id>      # proposed → active (picker if id omitted)
/preferences reject <id>       # proposed → rejected
/preferences deprecate <id>    # active → deprecated
/preferences undo <id>         # M3: strong-signal auto-activations within the undo window (picker if id omitted)

When id is omitted in interactive mode, the REPL renders a picker sourced from the appropriate state queue (approve/reject from proposed; deprecate from active; undo from auto-activated rows inside the 24h window). All four mutations are CAS-guarded: a concurrent writer that beat your call returns a targeted error with the row's current state, not silent overwrite.

M3 brings two new automatic behaviors:

• strong-signal keyword auto-activation: a user message containing an unambiguous negation (never, 绝不, kill switch, etc.) targeting a tool-action verb (trade, buy, swap, …) creates a hard_constraint and auto-activates it. The LLM appends a notice to its reply telling you what was remembered + the undo path. Default 24h window per PREFERENCE_HARD_UNDO_WINDOW_HOURS.
• tool-level enforcement: once a hard_constraint is active, swap_tokens / buy_token / sell_token / transfer_token / open_perps_position / minara_autopilot_create refuse to execute when the intent's subjects overlap the constraint. The refusal error points at /preferences deprecate <id> for the permanent override.

Each preference has three classifying axes: kind (one of personal_style, behavioral_preference, hard_constraint), dimension (e.g. risk, asset_class, methodology, style, constraint), and state (proposed, active, deprecated, rejected).

When PREFERENCE_LEARNING=1, the agent loop also surfaces preference graduation cards in-chat — every few turns you may see the agent ask something like "I noticed you keep mentioning X — want me to remember this as a permanent preference? (yes / no / later)". Reply directly in the chat; the parser maps your reply (bilingual EN+ZH) to the same approve / reject / deprecate transitions above. later snoozes the ask for PREFERENCE_ASK_COOLDOWN_HOURS (default 24h).

/context

Zero-LLM token estimator across the current system prompt, conversation history, and tool set. Warns when the context is getting large and suggests /compress.

/prompt

Dump the fully rendered system prompt blocks (identity, catalog, active skills, signal context, pending confirmations). Each block is truncated for readability. Useful for debugging prompt construction and cache boundaries.

/compress

Condense the oldest history now instead of waiting for the context window to fill. Runs the same compaction the agent performs on its own: the oldest turns collapse into a summary, the most recent stay verbatim, and your own messages are carried across in their original wording inside a token budget. Costs one extra LLM call.

The summary extends the session's existing one rather than starting a separate record, so a manual pass and an automatic one are the same thing at different times. Nothing happens if the history is short enough that everything falls inside the protected recent turns.

/compress

Skills and workspace

/skills [list|active|activate <id>]

Inspect or force-activate domain skills.

/skills                    # show the catalog
/skills list               # equivalent
/skills active             # only currently active skills
/skills activate market.spot

/skills activate goes through the same L3 risk gate as the LLM's activate_skills tool. High-risk skills still produce a pending confirmation.

/skill-search <query>

Search the skills.sh ecosystem for installable third-party skills, ranked by install count. The agent runs search_skills and shows the top owner/repo@skill candidates. Web surface only; in the REPL use minara skills search instead.

/skill-install <owner/repo>[@<skill>]

Install a skill from the skills.sh ecosystem. The agent runs install_skill, which downloads the package, writes a tracked Minara package, and reloads the catalog so it's usable in the same session. A bare owner/repo installs every skill in the repo. Web surface only; in the REPL use minara skills install instead.

/workspace [soul|agents|identity|user|memory|heartbeat|bootstrap]

Print a workspace md file via the workspace loader. The runtime workspace lives at ~/.minara/workspace/ (override with the --workspace flag or MINARA_WORKSPACE_DIR env). Defaults to soul when called without arguments.

• soul: SOUL.md — identity, voice, boundaries.
• agents: AGENTS.md — session startup rules, safety defaults.
• identity: IDENTITY.md — display name, emoji, vibe.
• user: USER.md — user profile (timezone, focus, risk tolerance).
• memory: MEMORY.md — curated long-term facts, preferences, decisions.
• heartbeat: HEARTBEAT.md — between-session memo (last_seen, open loops, notes-to-self, user-owned ## Schedule).
• bootstrap: BOOTSTRAP.md — first-run onboarding playbook. Archived as BOOTSTRAP.md.done.<timestamp> after the agent acknowledges with BOOTSTRAP_DONE.

To edit these files interactively, use the Web UI's Settings → Workspace panel (manual save with sha256 OCC), or edit them on disk while the agent is between sessions.

/soul

Alias for /workspace soul. Prints the active SOUL.md.

/identity

Alias for /workspace identity. Prints the active IDENTITY.md.

/heartbeat

Alias for /workspace heartbeat. Prints the active HEARTBEAT.md, including the ## State block (last_seen / session_id / turn_count / last_user_query), ## Open loops, ## Notes to self, and the user-owned ## Schedule section.

/add-dir [--permanent] <path>

Lets the assistant read and write inside a folder outside its own workspace. By default the grant lasts only for the current session; pass --permanent to keep it across restarts. The app's own data directory and any folder above it can't be authorized. Credential files inside an authorized folder (.env, id_rsa, *.pem, *.key, .aws/credentials, …) stay read-blocked.

/remove-dir <path>

Removes a folder from the allowed list (both the session grant and any permanent grant for that path).

/list-dirs

Shows the folders the assistant may use beyond its workspace, split into "always allowed" (permanent) and "allowed this session".

Finance

/kill

Activate the trading kill switch. Halts every tool at tier ≥ 2 until /unkill is called. Writes an entry to tier_events so the decision is auditable.

/unkill

Deactivate the kill switch and resume trading.

/status

Print risk manager status: kill switch state, daily spend, total tools registered, review engine state, active skill session.

/budget

Today's LLM spend by task category. Read from learning/budget-tracker.ts against the daily_spend table.

/autopilot list

List enabled autopilot strategies with their symbols and per-trade caps. Read-only view. Autopilot is started and stopped from the REPL via the agent rather than from this command.

/x402 preauth [list|grant|revoke|help]

Manage x402 paywall pre-authorization sessions. A session lets the agent auto-pay (no per-call confirmation) for matching x402 paywalls until the TTL expires, the budget is exhausted, or the session is revoked. The grant call itself ALWAYS goes through the unified confirm gate; only the per-call payments inside the session window skip the prompt.

/x402 preauth list [--all]
    # active sessions only by default; --all includes revoked / expired / exhausted

/x402 preauth grant <scope> [opts]
    # scope: provider:<id> | domain:<host> | any
    # opts:  --ttl 24h | --ttl 7d | --ttl forever
    #        --per-call <USDC>  --budget <USDC>  --chain <chain>

/x402 preauth revoke <session_id>
    # immediate; subsequent payments fall back to two-step confirm

scope=any + ttl=forever is the most permissive grant possible — the handler requires double-explicit yes/yes confirmation in the REPL before persisting. Caps (--per-call, --budget, --ttl) are bounded by the env vars in Environment Variables → x402 paywall pre-authorization. Set X402_PREAUTH_DISABLE=1 to short-circuit the entire feature during incident response.

Observability

/scenarios [pending|list|show|approve|reject|deprecate|debug|purge]

Manage the L0.5 scenario learning system. Requires SCENARIO_LEARNING=1.

When an <id> argument is missing, the REPL offers an interactive picker via pickFromList. Non-interactive contexts (HTTP gateway, tests) get a Usage: error instead.

Source: apps/agent/src/gateway/repl-commands.ts — scenariosCommand.

/migrate [export | import | manifest] (M5)

Export or import the full Minara configuration as a .tar.gz bundle. Three sub-commands, all of which thin-dispatch to the same handlers as minara migrate export|import|manifest:

• /migrate export [--packages defaults|all|csv] [--output PATH] [--passphrase-env ENV] Write a bundle of the chosen packages to disk.
• /migrate import <bundle> [--strategy merge|replace|audit-only] [--packages csv] [--confirm-hard] [--passphrase-env ENV] Apply a bundle to the live system.
• /migrate manifest <bundle> Print the bundle's manifest without unpacking the rest.

Bundles contain up to 10 packages (6 default-on, 4 opt-in). The secrets package requires passphrase encryption; the hard_constraint rows in the preferences package require an explicit --confirm-hard. See the CLI subcommands reference for the full per-package table.

Source: apps/agent/src/gateway/repl-commands.ts — migrateCommand.

/methodologies

List graduated trading methodologies by asset class with pass/fail counts. See Learning System.

Automations (created + managed through chat)

Automations (trigger plus a linear graph of agent / code / notify nodes) are created and managed conversationally through the automation skill, which drives the automation_* and automation_run_* tools. There is no bespoke /workflows or /automations slash command; ask the assistant in plain language ("remind me to check BTC every morning", "alert me when ETH drops 5%") and it authors, validates, and arms the automation for you.

/agent-list, /agent-archive

Read-side shortcuts for agent-shaped automations. They replay a natural language request to the assistant, which answers via the automation_list / automation_set_state tools.

/agent-list                      # list your agents
/agent-archive <agent id>        # archive an agent

Source: apps/agent/src/gateway/repl-commands-minara.ts.

/recall <role> [query…]

BM25-ranked search over reflected cases for a specific reasoning role. Only cases that have been reflected on AND classified as logic_error / missing_data are returned — variance and exogenous cases are stored for audit but filtered from retrieval so noise never pollutes future reasoning.

Without a role argument, the REPL prompts you with a numbered list of declared roles (derived from every skill's memoryRoles). Without a query, it prompts for one interactively.

Output: case id, decision tag, outcome %, error type, decision prose, and the reflected lesson.

/reflect <role> [--force] [--asset BTC]

Run the RoleMemoryReflector against pending entries for a role. For each entry old enough to satisfy the role's minAgeHours gate the reflector:

1. collects the outcome (price delta or custom probe)
2. runs the role's post-hoc probes in parallel (news, price trajectory, on-chain events)
3. asks the LLM to classify as logic_error / missing_data / exogenous / variance
4. for the first two types only, asks the LLM to produce a crisp actionable lesson keyed on the role's declared failure modes
5. writes everything back via role_memory

--force bypasses the minAgeHours gate (debug only). --asset limits the sweep to pending entries for a single ticker.

Summary output counts reconciled / skipped / errors and breaks the reconciled set down by classification type.

/logs [N] [--level debug|info|warn|error]

Print the last N log entries from the in-memory ring buffer (default N=30). Optionally filter by level. The ring buffer is separate from the on-disk daily log; this command gives you a snapshot of the current session.

/logs
/logs 100
/logs 50 --level warn

/loglevel [debug|info|warn|error]

Get or set the stderr log mirror threshold. File logging always captures debug; this only affects what's echoed to your terminal.

/loglevel               # show current
/loglevel debug         # set

Institution mode

/institution <ticker | ticker1 ticker2 … | natural-language query> [debate] [risk]

Convene the multi-agent institution. Builds a natural-language replay message that calls the minara_institution_analyze tool through the agent loop, so the normal skill-activation and confirmation hooks still apply. The tool itself is read-only — it returns a Markdown report + a structured proposal but never moves funds. To act on a recommendation, explicitly invoke a fund-moving action (swap_tokens / open_perps_position / the strategy-codegen skill's deploy.sh) on a separate turn; each enforces its own two-step preview / confirm gate.

The REPL detects three input shapes and dispatches the matching tool parameter:

Free-form queries flow through the tool's clarify-loop: if the quick-LLM extractor returns ambiguous candidates the tool replies with status: "waiting_for_input" and the REPL surfaces the candidate list for you to confirm before re-calling.

The optional debate and risk positional integers (only applicable in single-ticker mode) override INSTITUTION_MAX_DEBATE_ROUNDS and INSTITUTION_MAX_RISK_ROUNDS for one call (clamped to [1, 5]).

If no input is provided, the REPL prompts for it interactively.

/institution BTC
/institution AAPL 2
/institution ETH 2 2
/institution BTC ETH SOL
/institution 请分析SpaceX和OpenAI上市后哪个更值得买

Cost note: a single run is roughly 25 LLM calls; multi-ticker scales that by min(N, INSTITUTION_MAX_PARALLEL_TICKERS) (default 5). See Institution Mode env vars.

/institution-history [--ticker BTC] [--limit 20]

Aliases: /inst-history

List recent Institution Mode runs from the institution_runs SQLite table. Shows run_id, ticker / asset_class, the PM's 5-tier rating, holding status (open / auto_stale / finalized), the linked report://... artifact, the PM thesis (truncated), and a per-window alpha summary built from the institution_reflections rows that the daily cron has accumulated.

/institution-history
/institution-history --ticker BTC
/institution-history --limit 30

For non-interactive batch / cron use, the same data is available via minara institution history — see the subcommands reference.

Multi-ticker mode

Pass tickers: ["BTC", "ETH"] (or use natural language like "BTC vs ETH 怎么选") and the institution runs Phase 1-6 in parallel for each candidate (capped by INSTITUTION_MAX_PARALLEL_TICKERS, default 5), then a Phase 7 Allocator role synthesises across them into a single AllocatorRecommendation covering compare / allocate / hybrid mode. The optional intent argument (compare | allocate | auto) hints which mode the Allocator should favour; default auto infers from the input mix.

Deep research

/deep-research [<topic…>] [--mode light|heavy]

Aliases: /deep, /dr

Run the multi-stage Deep Research flow through the normal REPL turn runner. Without a topic, the command restores the most recently selected profile (Standard initially) until you disable Deep Research; running it again disables it. Use --mode heavy while enabling or running a topic to select Professional.

/deep-research BTC ETF flows in 2026
/deep "NVDA competitive position" --mode light
/dr "SPX mean reversion" --mode heavy

Minara wallet, trading, and market shortcuts

These commands are typing shortcuts for the Minara wallet, trading, and market APIs. Every handler builds a natural-language replay message that goes through the agent loop, so the normal skill activation and confirmation hooks still apply. Fund-moving commands embed a fresh-confirmation envelope regardless of prior "yes" answers in the session.

Source: apps/agent/src/gateway/repl-commands-minara.ts.

Wallet and crypto market reads

/balance

Aliases: /portfolio

Show the full portfolio across every wallet and chain.

/positions

Show open perps positions with PnL.

/tx-status <transaction-id-or-hash>

Aliases: /tx

Check whether a transaction confirmed on-chain. Pass the transaction_id or tx hash from a trade receipt; the agent reports pending, confirmed, or failed, the failure reason if any, and an explorer link. Missing the id, the REPL prompts for it.

/tx-status 0x9f3c...a12b
/tx 8e2a1f04-...-c9

/crypto <ticker> [chain]

Look up a crypto ticker and get a short summary (price, 24h change, 7d trend, market cap, sentiment, one-line takeaway).

/crypto btc
/crypto sol solana

/trending [crypto|stocks|all] [--category <name>]

Trending markets — defaults to both crypto and stocks. Pass crypto or stocks to narrow the scope.

/trending
/trending crypto --category memes
/trending stocks

/markets [type | sector | symbol]

Aliases: /markets-overview

A market briefing. With no argument, a full cross-asset overview: indices, futures, forex, treasury yields, sector rotation, crypto fear & greed, top movers, headlines, and upcoming earnings. Pass an asset type (crypto, stocks, commodities, forex, indices) to focus on one class, a sector or track (defi, AI, tech) for sector rotation, or a ticker for a focused deep-dive.

/markets
/markets crypto
/markets defi
/markets BTC

/search <query>

Search tokens or tickers by name. Query is rest-of-line — no quoting needed.

/fear-greed

Aliases: /fg

Crypto fear & greed index snapshot.

Stocks and equities (FMP-backed)

Stock commands discover typed FMP operations through tool_search({ namespace: "cap/fmp", query }), inspect the selected operation with tool_describe, then invoke it directly.

/stock <ticker>

Aliases: /quote

Quote a stock: price, day change, market cap, P/E, 52-week range.

/financials <ticker> [annual|quarter]

Latest income statement, balance sheet, cash flow, and key ratios. Defaults to quarterly.

/earnings <ticker>

Upcoming earnings date and last 4 quarters EPS actual vs. estimate.

/analysts <ticker>

Analyst price targets, ratings distribution, recent rating changes.

/news <ticker>

Latest company news headlines.

/filings <ticker>

Recent SEC filings (10-K, 10-Q, 8-K) with dates and links.

/compare <ticker1> <ticker2> [ticker3…]

Side-by-side comparison of 2+ tickers: P/E, gross margin, revenue growth YoY, market cap, analyst price targets.

/compare aapl msft nvda

/earnings-review <ticker>

Aliases: /er, /earnings-note

Full post-earnings review for a covered name: pulls the print + 8-K

• analyst consensus in parallel, attempts to read the call (best-effort via 8-K Exhibit 99.1 → IR website), builds a variance table, writes the coverage model to earnings/<TICKER>/<YYYY-Qn>-model.xlsx, and drafts the post-earnings note with a recommendation block to earnings/<TICKER>/<YYYY-Qn>-note.docx.

Distinct from /earnings, which is a quick read of the earnings calendar + last 4 quarters EPS — /earnings-review produces drafts for human review.

/earnings-review NVDA

/tlh

Aliases: /harvest

Tax-loss harvesting scan over the current portfolio. Pulls realized YTD PnL + activities + holdings, identifies positions with material unrealized loss, runs the wash-sale screen across the 61-day window (±30 days), and recommends 2-3 replacement securities per viable candidate that maintain factor exposure without triggering the wash-sale rule. Output is a CSV under tax/tlh-candidates-<YYYY-MM-DD>.csv plus a chat summary.

Always leads with the standard "Not tax advice" disclaimer block — TLH involves jurisdiction-specific rules and the user must consult a licensed CPA before acting. Read-only. Execution uses the standard trade tools.

/tlh

/sector <theme>

Sector or theme deep-dive deliverable. Builds the universe via thematic ETFs / DefiLlama categories, fans out parallel comps for both equities and crypto when the theme is hybrid, then writes a markdown report to research/sector/<theme>-<YYYY-MM-DD>.md covering thesis, macro context, two comps tables, a bridge paragraph, top picks, risks, and catalysts.

For hybrid themes (e.g. AI infrastructure, DePIN, stablecoin issuers), the report covers BOTH equity and crypto sides plus a connective bridge paragraph — Minara's differentiating output over Anthropic's reference market-researcher agent (which is equity-only).

/sector AI infrastructure
/sector DePIN landscape
/sector regional banks

Macro markets

/commodity <symbol>

Aliases: /comm

Quote a commodity (e.g. GCUSD gold, CLUSD crude, SIUSD silver).

/fx <pair>

Aliases: /forex

Quote a forex pair (EURUSD, USDJPY, GBPUSD, …).

/index <symbol>

Aliases: /idx

Quote a market index (SPX, NDX, DJI, VIX, …).

/macro

One-screen macro snapshot: SPX, NDX, VIX, US10Y, DXY, gold, oil, BTC — one line each plus a two-sentence overall read.

Fund-moving: spot trades and transfers

Every fund-moving command embeds a structured ```minara-confirm envelope and a fresh-authorization clause, so prior "yes" answers in the same session do not auto-approve. Confirmation gates are always re-run for these commands regardless of the tool's CONFIRM_ONCE tier.

/swap <amount> <from> <to> [chain]

Swap one token for another. Dry-runs first, then requires explicit confirmation on the quote.

/swap 0.5 usdc eth
/swap all eth usdc base

/buy <amount-usd> <token> [chain]

Buy a token with USD/USDC. A leading $ on the amount is accepted.

/buy 50 btc
/buy $100 sol solana

/sell <amount> <token> [chain]

Sell a token to USDC. Balance-checked before the quote — refuses to auto-swap from another asset if the balance falls short.

/send <amount> <token> <address> [chain]

Send tokens to an address. Address is loosely validated (EVM hex, Solana base58, or name.eth/name.sol) and read back to you character-by-character inside the confirmation envelope.

/pay <amount> <address> [token] [chain]

Same as /send but defaults to USDC when the token is omitted.

Fund-moving: perps

/long <token> <margin-usd> [leverage]

Open a long perps position. margin-usd is the collateral. Leverage is optional — append it like 10x.

/long btc 500 10x
/long eth $200 5

/short <token> <margin-usd> [leverage]

Open a short perps position. Same shape as /long.

/close [<token|all>]

Aliases: /close-order

Close a perps position. If you omit the target, the REPL fetches your live positions and renders a numbered picker — reply with the index, the token, or a/all. Only touches positions, not resting limit orders.

/close               # interactive picker
/close eth
/close all

/cancel [<order-id|all>] [symbol]

Cancel an open perps order (or all). When called bare, the REPL prompts for the order id — run /positions or ask the agent to list open orders first so you know which id to type. Use /cancel all to cancel everything, or /cancel all <symbol> to scope to one symbol.

Funding

/deposit [crypto|card]

Start a deposit flow. Without an argument, the agent asks which method you prefer. crypto shows addresses, card returns a MoonPay-style on-ramp link.

/receive

Show deposit addresses across every supported chain.

Factor Research

/factors

Open the interactive factor-research menu. It can create a persistent time-series research campaign, list or control campaigns, review qualified candidates, browse approved factor versions, and explain metrics. The providers action lists, checks, enables, disables, imports, and archives factor data sources without exposing saved credentials.

Campaign creation asks for only four core groups: the research goal, asset and period, optimization objective, and budget. Advanced research settings remain available through the API and CLI. Optimization objectives control search priority and ranking; stopping conditions control when search pauses or ends without changing the qualification gates.

The command never approves a factor automatically and does not deploy a strategy, trade, or move funds.

Strategy Studio (BETA)

End-to-end author → backtest → optimize → deploy flow on the Minara Strategy Studio surface. The /strategy-new command authors locally: it replays a prompt that tells the agent to activate the minara-strategy-codegen skill, write the strategy as a .ts file in its sandbox, and backtest it with that skill's scripts. The skill fetches the live pine-runtime syntax per run, so a syntax change upstream needs no client change. Deployment runs on the upstream engine; the authoring artifacts (code, version history) live locally.

The strategy lifecycle commands (/strategy-deploy, /strategy-start, /strategy-stop) do NOT prompt for a fresh confirmation — _deploy is the one-time authorization moment, after which start / stop / config updates are scheduling on an already-authorized strategy. The agent still surfaces a structured preview before each call.

/strategies [status]

List strategies you own. Pass an optional status (e.g. ACTIVE, INACTIVE) to filter. Renders id, name, status, symbol, and PnL inline — does not call the LLM.

/strategies
/strategies ACTIVE

/drafts

List your strategy-studio AI chat drafts (chat session id, title, latest version, last update). Read-only, does not call the LLM.

/marketplace [search]

Browse the strategy marketplace. Optional positional turns into a tag filter. Read-only.

/marketplace
/marketplace BTC trend

/strategy-new <symbol> <interval> <goal>

Author a new strategy locally. Replays a prompt that tells the agent to activate the minara-strategy-codegen skill, write the strategy as a .ts file in its sandbox, and backtest it with that skill's scripts. The agent iterates in an open loop (read errors, edit the file, re-run), then saves the code as a formal version with the skill's version.sh save.

/strategy-new BTCUSDT 1h rsi mean reversion with bollinger bands
/strategy-new ETHUSDT 4h trend following with macd

/strategy-deploy [strategyId|chatId]

Deploy a strategy to live. Without an argument, the REPL fetches your strategies and prompts you to pick. The agent then runs the strategy-codegen skill's deploy.sh without --confirm to print a structured preview (symbol, interval, leverage, sub-account), relays it, and only after your explicit OK re-runs the same command with --confirm.

/strategy-start <strategyId>

Start a stopped strategy. Bare invocation pickers from the inactive list.

/strategy-stop <strategyId>

Stop a running strategy. Bare invocation pickers from the active list. The default stop market-closes open positions (--keep-positions leaves them open); the agent previews first and executes only after your explicit OK.

/strategy-backtest [strategyId|chatId]

Run a backtest on a saved version: the agent fetches the code with the strategy-codegen skill's version.sh get, then runs backtest.sh on it. One-off checks on a local .ts file skip the fetch.

Registry shape

Each command is a ReplCommand:

interface ReplCommand {
  name: string;           // "/status"
  aliases?: string[];     // ["/kill-switch"]
  description: string;    // one-line summary for /help
  usage?: string;         // "/skills [list|active|activate <id>]"
  category: Category;     // "session" | "agent_control" | ...
  run(argv: string[], ctx: ReplContext): Promise<ReplResult>;
}

The BUILTIN_COMMANDS array in repl-commands.ts lists them in display order for /help. Adding a new command means appending to that array and creating a new page section here in the same commit. See Conventions §6.