Slash Commands

The slash-command subsystem of the pindus / induscode interactive console: a typed line like /model, /resume, or /export out.html is parsed, resolved against an ordered registry, and run as a thin async handler that acts only through an injected context. The pure framework lives at induscode.console_slash; the ~26-command catalog lives at induscode.console.slash_commands.

Table of Contents

• Overview
• Two packages
• Resolution pipeline
• The command catalog
• Transcript and session control
• Workbench pickers, help, diagnostics
• Integrations: auth, MCP, memory, composio, IO
• Dynamic rows: skills and templates
• Family commands
• The registry as a value
• How dispatch works
• Public API
• Notes and parity

Overview

When you type a line into the composer the console routes it in a fixed order: a leading !/!! is a shell escape; otherwise the line is resolved against the slash registry; otherwise it is submitted as a plain prompt. The slash layer owns that middle step — turning the raw string into a discriminated outcome (NotSlash / Match / Miss) and then await-ing the matched command's handler.

The subsystem is deliberately split so the parsing/resolution machinery never depends on the live console. Handlers are uniform and thin: every one is

async def run(ctx: SlashContext) -> SlashOutcome: ...

and reaches the terminal only through the SlashContext it is handed (open a modal, dispatch a reducer event, set a status toast, append a display block, request exit, or return a Prompt for the dispatcher to submit). That keeps handlers pure with respect to the TUI and trivially fakeable in tests.

Two packages

The catalog imports SlashCommand, SlashContext, HANDLED, info, warn, family_runner, and SubCommand from induscode.console_slash and folds its rows through build_registry. The framework never imports the catalog (clean leaf direction).

Resolution pipeline

Resolution is two pure functions over a string and a registry. None of it touches I/O, the conductor, or the TUI.

1. parse_slash(line) decides whether the line is command-shaped and, if so, splits it into a SlashLine(name, args). A line qualifies only when — after trimming leading blanks — it starts with / and the token matches ^[a-zA-Z][a-zA-Z0-9:-]*. A bare /, a //comment, and a /usr/local/bin path are all rejected (the embedded slash breaks the token shape), so those reach the prompt untouched. The token is lower-cased; the argument tail keeps its interior spacing.
2. resolve_slash(line, registry) parses the line, then looks the token up in the registry index and returns a SlashResolution:

from induscode.console_slash import resolve_slash
from induscode.console.slash_commands import DEFAULT_SLASH_REGISTRY

res = resolve_slash("/branch since the refactor", DEFAULT_SLASH_REGISTRY)
assert res.kind == "match"
print(res.command.name, repr(res.args))  # 'branch' 'since the refactor'

miss = resolve_slash("/nope", DEFAULT_SLASH_REGISTRY)
assert miss.kind == "miss" and miss.name == "nope"

not_cmd = resolve_slash("/usr/local/bin", DEFAULT_SLASH_REGISTRY)
assert not_cmd.kind == "not-slash"  # embedded slash -> reaches the prompt

Resolution is case-insensitive on the command token, and an alias resolves to the same row as its canonical name (/fork resolves to branch).

The command catalog

build_catalog(cwd, home) concatenates three static groups in listing order, then splices in the discovered dynamic rows:

transcript_commands (11)  ->  workbench_commands (7)  ->  build_integration_commands (8)
                          ->  dynamic /skill:<name> + /<template-name> rows

There are roughly 26 static commands (11 + 7 + 8), plus N discovered dynamic rows. Counting aliases as invokable tokens (reset, condense, compact, sessions, fork, tree, models, scoped-models, ?, hotkeys, changelog) it is about 36 resolvable tokens.

cwd and home are explicit arguments — there are no import-time filesystem scans. The process-default registry is built once by build_default_registry() from the real os.getcwd() / ~ and cached; SLASH_COMMANDS and DEFAULT_SLASH_REGISTRY are lazy module attributes (PEP 562 __getattr__) minted on first access. Building the default registry also installs it as the /help provider (see Family commands).

Transcript and session control

The first group resets, renames, branches, inspects, or leaves the live session. Pickers open an overlay through ctx.open_modal(...); the rest drive the conductor.

/clear and /new both wipe the rendered view and call conductor.new_session() — the conductor reset is what actually empties the transcript, since the rendered conversation comes from conductor.messages().

Workbench pickers, help, diagnostics

The overlays a user reaches to inspect or retune the session, plus the live help and keymap surfaces. See Theming for the scheme picker (reached via /settings, not a dedicated command).

/help reads the live catalog through a late-bound provider, so it lists the dynamic /skill: and /<template> rows too. /keys renders the grounded chord/effect table — Enter (submit), Shift+Enter (soft newline), Esc Esc (tree navigator), Ctrl+C (interrupt), Ctrl+L (model picker), Ctrl+R (resume list), ! <cmd> / !! <cmd> (shell escapes), and the rest.

Integrations: auth, MCP, memory, composio, IO

The bridge group is minted by build_integration_commands(runtime) over one per-console IntegrationsRuntime holder (its mcp_pool, composio_gateway, memory_enabled flag, and tracked tasks). It builds on the framework MCP facade and connectors.

# inside `pindus` / `induscode` interactive session
/mcp connect             # build + connect the workspace MCP pool, show status
/composio enable github  # hydrate a Composio toolkit's tools
/export out.html         # render the live transcript to HTML
/share                   # publish the transcript as a secret gist
/copy                    # last reply -> clipboard

/composio needs COMPOSIO_API_KEY in the environment; without it the verbs surface a "Composio is not configured" status. See MCP configuration and Transcript Export.

Dynamic rows: skills and templates

Two row shapes are discovered, not hand-written, by scanning .indusagi/skills and .indusagi/commands under the project (cwd) then user (home) roots (via the briefing layer). Both return a Prompt outcome the dispatcher submits as a normal turn:

• /skill:<name> — submits an Agent-Skills invocation block <skill name="..." location="...">body</skill>, where the trailing argument becomes the body. So /skill:commit tidy the diff runs the commit card against "tidy the diff".
• /<template-name> — expands the macro body against the trailing arguments (single-pass $arg model) and submits the expansion.

Discovery never raises (a missing root yields nothing), templates are deduped first-wins, and any dynamic token that collides with a reserved static token is dropped — so splicing dynamic rows can never make build_registry raise.

Family commands

A command with sub-verbs (/models-for, /memory, /composio) is built from a SubCommand table via family_runner, never a hand-written if-ladder. The runner splits the leading verb, dispatches by dict lookup, and falls back to a usage toast assembled from the table's descriptions when the verb is missing or unknown.

from induscode.console_slash import SlashCommand, SubCommand, family_runner, HANDLED, info

async def _on(ctx, rest):
    ctx.set_status(info("enabled"))
    return HANDLED

run = family_runner("demo", (SubCommand(verb="on", describe="turn on", run=_on),))
cmd = SlashCommand(name="demo", summary="toggle demo", run=run, family="demo", takes_args=True)
# bare '/demo' -> usage warn "on (turn on)"; '/demo on' -> _on

FAMILY (a FamilyLabels record) names the labels: composio, memory, models-for (scoped models), and theme. theme is declared for parity but no /theme command ships — the scheme picker is reached via /settings.

/help sourcing uses the same pattern in reverse: instead of importing the catalog at call time (a cycle, since the catalog imports the help module), set_help_registry_provider late-binds the assembled registry at registry-build time. Until one is installed, /help falls back to the static transcript + workbench groups.

The registry as a value

SlashRegistry is an immutable ordered command tuple plus a derived token-to-command index (MappingProxyType). Adding a command is appending a row to a group; resolution, completion, and grouping are all pure derivations:

• build_registry(commands) folds the ordered list into the registry, lower-casing every token (name + aliases). It raises ValueError on any duplicate token — loud at assembly time, never silent shadowing.
• find_command(registry, token) — exact lookup (canonical or alias, leading slash optional).
• match_prefix(registry, partial) — the completion candidate set, in registry order; an empty partial returns the whole list.
• list_families(registry) / commands_in_family(registry, family) — family labels in first-seen order and the rows in a family, for /help grouping.

from induscode.console_slash import build_registry, match_prefix
from induscode.console.slash_commands import build_catalog

catalog = build_catalog(cwd="/work/proj", home="/home/me")
registry = build_registry(catalog)
candidates = match_prefix(registry, "mo")  # /model, /models-for, ...
print([c.name for c in candidates])

How dispatch works

The effectful dispatcher is not part of this subsystem — it lives in the ConsoleApp (console/app.py). On a submitted line the app follows the verbatim routing order:

1. A leading ! / !! escapes to conductor.execute_bash.
2. Otherwise resolve_slash(line, self._slash) runs.
3. On Match, the app constructs a SlashContext from its own callables (dispatch, _open_modal, close_modal, _request_exit, set_status, _set_buffer, append_block, plus the SessionConductor) and awaits resolution.command.run(ctx). A Prompt outcome is fed to the turn runner; Handled ends the line.
4. On Miss, an "Unknown command" warning is surfaced.
5. On NotSlash, the line becomes a normal prompt.

open_modal kinds map to the console's ModalKind / MODAL_KINDS vocabulary (settings, models, scopedModels, sessions, tree, userTurns, signIn, signOut, plugin, ...). See Console Overview for the surface and Dialogs for the overlays.

Public API

induscode.console_slash (framework)

induscode.console.slash_commands (catalog)

Notes and parity

• Roughly 26 commands, not "30+": 11 transcript + 7 workbench + 8 integration static rows, plus the discovered dynamic rows.
• No /theme command ships. FamilyLabels.theme is declared for parity but the scheme picker is reached via /settings only. /export is HTML only.
• Every handler is async and awaited. Fire-and-forget bodies (the /clear session reset, the Composio settle paths) ride tracked asyncio tasks that swallow their own failures into a status warn — never bare tasks.
• /summarize-context with guidance records the guidance via conductor.execute_bash(printf ...) then runs the parameterless condense() — the closest real action on this build.
• /memory on|off only flips the IntegrationsRuntime.memory_enabled reporting flag; it does not detach the memory tool from the live capability deck.
• build_registry raises on any duplicate token at assembly time; build_catalog pre-reserves static tokens so a colliding discovered skill/template is dropped rather than crashing the build.
• The /mcp status text currently hints .indusvx/mcp.json while the dynamic roots resolve under .indusagi/ — a known stale-string inconsistency.

This area is a clean-room rebuild of the TypeScript console-slash lineage; see Parity for the documented port deltas.