Feature reference · pre-release

Commandem feature reference

Find every declared app surface, settings defaults and visible CLI command, with scope, safety and provider limits.

Reviewed October 23, 2026. This reflects the current source code, not a certified running build or a public release announcement.

Find a feature

Search features, settings defaults and CLI summaries. Search stays local: no network request or saved query.

  1. Feature lookup

    Use this Reference index to reach a worked feature chapter with entry points, limits and examples.

  2. Task workflow

    Use the Handbook for a step-by-step guide, such as reviewing a conversation handoff.

  3. Exact command

    Use the CLI examples and command reference to inspect syntax and side effects before acting.

Choose by intent: understand a feature, follow a procedure or inspect a command. The three paths complement each other; reference coverage alone is not runtime certification.

Expand a group below to browse all entries. Local search becomes available when JavaScript loads.

Workspaces (7)
  • Command Center

    Open Command Center from the palette or return to Overview with no project selected. Home aggregates work needing attention and offers configurable widgets. Selecting a card follows its underlying project, run or message; it is not a second authority or data store.

  • Monitor

    Open Monitor from the palette for project health, agent runs and signals. Inspect a signal's source and timestamp before acting; filtered or paged lists are bounded views, not full archives.

  • Replay

    Replay reconstructs a run's recorded events, gate evidence and known causes. Open a run or receipt first when investigating why work stopped; distinguish recorded causal links from inferred explanations.

  • Experiments

    Use the Experiments workspace to find suites and recorded runs, then inspect their design, controls, outcomes and artifacts. The workspace indexes evidence; it does not make a result valid merely because a runner completed.

  • Automations

    Automations explains triggers and their effects. Inspect the trigger, project scope, configured action and resulting receipt before enabling recurring work. Scheduling preferences and notification schedules do not grant tool authority.

  • Matrix

    Matrix relates conversation evidence across projects and providers. Use relationships to find candidate context, inspect source evidence and review a handoff before another agent receives it.

  • Fleet

    Fleet is the standing-capacity and bounded-fan-out workspace, peered with the per-launch Swarm record view: Overview lists registered nodes and surfaces with an active-swarms strip, and Swarms lists dispatched swarms with a read-only detail (workers, phases, verdict and receipt totals) for a selected one. This is a review surface; starting, steering, killing, budgeting or adding/removing workers from here is not yet exposed.

Feature explanations (33)
  • Project news in Roadmap

    Read recent recorded project updates in the full Roadmap or its full and Glance companion. The expanded news region defaults to roughly half the available space and has a draggable divider. Its committed section height controls a row limit capped at twenty; each project's full Roadmap and Glance save separate resize preferences. Refresh checks the feed; Retry recovers an unavailable reader. After the initial load, Show latest updates applies a waiting snapshot without moving Mission reading position. Receiving updates preserves unsent task drafts in the full Roadmap and new-mission drafts in Glance. View updates opens an updates popover; Open recorded source is an explicit browser action; Done closes recorded details. Failed refreshes retain last good updates. No older paging or full-history claim.

  • Plan

    Open Plan in the palette to work across project roadmaps. Campaigns organize outcomes; Missions identify coherent work; tasks describe executable slices and dependencies. Research belongs in a Mission when it has a design and acceptance evidence.

  • Week

    Open Week for a weekly review of planned work and recorded progress. Use it to reconcile priorities and capacity across projects rather than dispatching from every status card.

  • Agent runs and queue

    Open Agent runs or Monitor to inspect queued, planning, awaiting-approval, executing and terminal work as exposed by the runner. Approve the exact planned run once and verify its branch and results independently.

  • Runner control

    Open Runner control to inspect unattended execution. Bounded turn, budget and progress preferences constrain auto-continuation; they are not an instruction to pursue arbitrary work.

  • Verification and Gate Composer

    Compose evidence-backed checks and inspect preflight before applying changes. A shell verification command and a browser URL check can be combined; the browser gate requires HTTP success and rejects JavaScript exceptions or console errors.

  • Run receipts

    Open Run receipts or the run detail for provider/account identity, execution results, gate evidence and failure reasons. Keep evidence links and redacted screenshots associated with their run.

  • Broadcast and announce

    Command Center's Broadcast inlet scopes run/queue/goal actions across projects. Announce routes a message to active chats; it is a communication path, not permission to execute the message.

  • Review, approvals and Git rollup

    Use Peer review workspace, Tool approvals, Review inbox, Review & merge agent branches or Git across projects from the palette. Inspect requested tool authority, branch contents and verification before approving or landing.

  • Provider history

    History reads the supported agent's session archive for the project/account. A folder rename can orphan path-keyed archives unless they are migrated. Check identity and working directory before concluding that a conversation was lost.

  • Native resume versus bridge

    Native resume continues a source-provider session under its owning account. A cross-provider bridge transfers reviewed evidence into a different conversation; it does not grant the destination ownership of the native transcript.

  • Context inspector and manifest

    Inspect which sources were selected, included, excluded or truncated in a context manifest. Source identity, revision, privacy provenance and payload accounting explain what the destination could receive.

  • Reviewed handoff

    Select candidate evidence, inspect the preview, remove irrelevant material and approve a current handoff. The transition contract binds plan, preview, review and current state to the payload and manifest draft.

  • Matrix labeling and learned models

    Human labels judge whether two conversations share useful objectives or evidence, not whether their wording looks similar. Related pairs should help continue actual work; insufficient evidence can be skipped. Cross-provider examples need deliberate coverage.

  • Causal investigation and memory

    Replay, context provenance and project memory help reconstruct trigger, evidence, mechanism, change and measured effect. Use source-backed links and state confidence explicitly when recording a lesson.

  • Profiles and named accounts

    Profiles collects provider configuration, native account references and project-specific selections. A named Claude, Codex or Gemini CLI account isolates provider-owned authentication roots. An API profile instead points to an endpoint.

  • Loadouts and role routing

    Loadouts bundle reusable routing and behavior choices, including account references per role. Project and pane overrides are distinct from the global default. Inspect role bindings before unattended work.

  • Modes and notification posture

    Notification preferences provide per-type delivery/priority behavior and a quiet posture. Select a declared mode where supported; inspect the current effective policy rather than assuming a profile name means Do Not Disturb.

  • Privacy and Data Use Gate

    Privacy separates provider data-use posture, local retention and delivery authority. A gate needs to know which account/endpoint will receive data; unknown training posture must stay unknown with a provider-setting link.

  • Incognito boundary

    Incognito concerns local retention and selected session behavior; it is separate from a provider's training policy. Verify provider support and the applicable local artifacts before sending sensitive information.

  • Usage, quota and capacity

    Open Provider usage or Home Usage to inspect account-scoped evidence. Reported windows, observed exhaustion, transcript estimates and API costs have different meanings. Quota exhaustion is distinct from model-capacity rejection.

  • Notes and comments

    Notes preserve editable project knowledge; comments attach discussion to project, Campaign or Mission scope. Inspect whether the current board is local or synchronized and whether the chosen provider supports the operation.

  • Board messages and notifications

    Board read state feeds Home and Notifications. Marking board messages read preserves their history. A notification badge should reflect the same underlying unread state, not an independent dismissal ledger.

  • Sync adapters and project-management bridges

    Inspect configured collaboration connections, scope mapping, authentication and conflict handling before synchronizing content. External project-management records can map to Campaign/Mission work, but the mapping must be explicit.

  • Recipes and Marketplace

    Recipes are reusable prompt/workflow templates; the Marketplace groups recipes, plugins and skills. Bundled catalogs load locally first; remote refresh has a separate unavailable state.

  • Plugins, skills and MCP tools

    Plugins extend commands; skills supply scoped agent instructions; MCP servers expose tools. Install through the supported manager and inspect declared capabilities, provenance and update evidence.

  • Governed agent-to-agent communication

    Advisories and read-only questions use a governed bus with an audit trail. Announce routes operator messages to active chats; source and destination identity are essential for coordination.

  • Saved Views and project defaults

    Save the current layout from the palette, inspect Saved Views, and assign an appropriate saved layout as the project's default. A saved view captures pane configuration; it does not copy the conversation transcript.

  • Workspace scope

    A Workspace groups projects and filters status/sidebar views. Select it with the workspace switcher; All projects clears that filter. Workspace export/import is distinct from layout saving.

  • Agent workbenches

    A workbench is an isolated Git working tree used for concurrent implementation. The primary checkout is the integration lane; branches are reviewed, tested, committed and landed back to trunk.

  • Command palette and menu routes

    Use the configured command-palette shortcut to discover global actions, Settings destinations and saved layouts. Static destinations are listed below; project-specific or user-defined entries may also appear.

  • Project tab layout

    The project tab bar groups Chat, Code, Terminal, Activity, Insights, Actions, Roadmap and Board. Layout preferences can hide/reorder groups, use icons and adjust sizes; Quick Open/shortcuts still reach hidden tabs.

  • Agents center and project personas

    Author .claude/agents instructions in Profiles, separately from Loadout routing and security policy.

Project tabs (16)
  • Chat

    Select a project and open Chat to send prompts, choose agent/account/model and inspect streamed replies, tools and attachments. A split layout can hold independently configured panes.

  • Files

    Browse project files and open a file in the configured pane or external application. Hidden and ignored files are controlled by Layout preferences. Resolve an attachment's actual path before handing it to another app.

  • Search

    Search within the selected project's code and files. Use the project selection and query to scope results, then open the matching file and line.

  • Log

    Inspect project log output and recorded activity while diagnosing a run or check. Match timestamps and run identity rather than inferring cause from neighboring rows.

  • Activity

    Read the project's timeline of commits, runs and transitions. Use it to locate evidence relevant to a status change and then open the original record.

  • History

    Browse provider-session history available to the current project and account. Open the original session for inspection or choose a supported resume path.

  • Matrix

    The internal tab identifier is graph; the visible product name is Matrix. Inspect conversation relationships and candidate context for this project, with source provenance.

  • Diff

    Inspect repository changes against the relevant base before review or merge. Confirm the branch, base and dirty worktree as well as the rendered patch.

  • Shell

    Open the selected project's terminal surface for commands. Confirm the working directory, account context and command before execution.

  • Config

    Inspect the project manifest and declared commands/conventions. The manifest connects project behavior to CLI checks and orchestration.

  • Stats

    Inspect project-level activity and resource summaries as available from their data sources. Use underlying receipts when exact accounting matters.

  • Actions

    Find configured project actions and run the intended operation after reviewing its scope. Actions use the project's declared workflow rather than an independent task system.

  • Roadmap

    Browse Campaigns, Missions, executable tasks, dependency state and completion evidence in the project roadmap. Use durable Mission IDs in links or dispatch references.

  • Board

    Read and send project board messages and scoped comments. Board read state feeds the unified notification system; historical messages remain after being marked read.

  • Notes

    Open project knowledge and editable notes. Keep reusable context distinct from transient conversation messages, and inspect the configured storage/sync destination.

  • Links

    Keep project resource links discoverable alongside notes and configuration. Open a URL or local resource with its intended handler.

Home widgets (17)
  • Fleet

    Project health and attention summary; open the source project to investigate a condition.

  • Committee audit

    Review-oriented overview; inspect the referenced work and approvals before accepting a conclusion.

  • Approvals

    Pending requests for tool authority. Decide on the exact operation, not all future requests.

  • Live chats

    Active conversation entry points. Opening a chat is different from authorizing a new turn.

  • Messages

    Unread board messages. Mark read preserves the underlying board history.

  • Recent lessons

    Recorded reusable project knowledge. Treat older lessons as evidence to review, not unconditional authority.

  • Live flow

    Work progression across tracked projects. Verify underlying run states when exact execution matters.

  • Branches

    Agent branch/review visibility. A branch listing does not prove it is safe or tested.

  • Usage

    Provider/account usage evidence. Reported quota, estimates and unknown values are distinct.

  • Inbox

    Work that needs human review. Dismissal is not a merge or approval.

  • Next action

    A proposed next step from current status. A recommendation is not permission to run it.

  • Stalled

    Potentially stalled work. Inspect heartbeat and logs before restarting owned processes.

  • Repositories

    Repository context and status. Confirm the actual worktree before applying Git operations.

  • Reminders

    Time-based prompts for follow-up; not proof an external task ran.

  • Machine and CLIs

    Local resource observations. High utilization needs process evidence before attributing it to a study.

  • Monitors and deploys

    Active monitoring context. A watcher expiring does not necessarily stop the work it observed.

  • Spend

    Available cost evidence. Subscription use may have no dollar meter; unknown cost is not free execution.

Sidebar (5)
  • Sidebar: Projects

    Global project list, current selection and workspace scope.

  • Sidebar: Files

    File navigation for the selected project; no selection means no project file root.

  • Sidebar: Search

    Search within the selected project; separate from conversation/Matrix retrieval.

  • Sidebar: Changes

    Repository changes for the selected project; inspect base and worktree before review.

  • Sidebar: Agents

    Global agent/run visibility and entry points.

Shortcuts (8)
  • Open selected project

    Command–O: Opens the selected project surface; requires a meaningful selection.

  • Acknowledge attention

    Command–D: Mutes current attention until project state changes; does not fix the condition.

  • Snooze selected project

    Command–E: Snoozes attention for 24 hours; project history is preserved.

  • Open command palette

    Command–P: Discovers app commands and destinations.

  • Previous project

    Command–[: Navigates the available project list in the current scope.

  • Next project

    Command–]: Navigates the available project list in the current scope.

  • MRU project switcher

    Control–Tab: Hold to cycle recent projects; this is not the OS Command–Tab switcher.

  • Open Notifications

    Command–Shift–B: Opens the unified notification surface, not the OS Notification Center.

Command palette (30)
Settings categories (12)
  • Settings: Profiles

    Provider configuration, named accounts, model/effort defaults, display identity, automatic continuation and exhaustion rules.

  • Settings: Loadouts

    Reusable per-role routing, behavior, tool and account references. Loadouts can reference projects and workspace/environment choices without copying credentials.

  • Settings: Security

    Tool approval boundaries, local policy, standing directives, protected capabilities and permitted elevated behavior.

  • Settings: Chat defaults

    Behavior when sending/relaunching, suggestions, smart replies, model reminders, active-turn handling and unattended detach defaults.

  • Settings: Audio

    Microphone input, local dictation preferences, voice-command confirmation, speech playback voice/rate/volume and auto-read.

  • Settings: Notifications

    Per-type delivery and priority, quiet behavior and notification appearance. Board messages and ordinary feed notifications use their underlying read/dismiss state.

  • Settings: Appearance

    Theme, accent, status colors, density, sender/timestamps, thinking labels, tool folding, fonts, bubbles, backgrounds and rendering preferences.

  • Settings: Layout

    Sidebar grouping/sort/visibility, tab groups and icons, splits, second-pane behavior, file-link target, hidden/ignored files and infrastructure visibility.

  • Settings: Projects

    How projects are listed and opened, default interaction behavior and project-oriented preferences. Inspect selected project scope before changing configuration.

  • Settings: Mobile

    Pairing and trusted-device configuration for the supported companion path.

  • Settings: Input Mouse gestures: capture, preview, cancellation and undo

    Configurable action bindings and their current overrides. See the shortcut reference for source defaults.

  • Settings: System

    Launch/quit behavior, raw settings access, integrations, recipe registry configuration, dependencies and backup/export tools.

Conversation styles (3)
Static controls (154)
Source defaults (76)

Scoped lookup addendum: the acp, codescan, op and setup entries copy their checked-in CLI declarations. This four-command target and summary repair does not renew the handbook review date or source, certify other summaries, or verify installed command behavior.

CLI commands (168)
  • commandem a2a

    Governed agent-to-agent bus (phase 388): stage Tier-1 advisories, ask Tier-2 read-only questions, read the audit ledger.

  • commandem agents
    Current declared help

    List .claude/agents/*.md across registered projects; `agents <project> --rename <old> --to <new>` renames a subagent (e.g. the Commander orchestrator); `--create`/`--edit`/`--delete <name>` author one (the Agents-center backend). Agent Builder: `--templates`, `--create --template <slug>`, `--validate`, `--source <name>` (print the exact stored TOML/YAML/JSON, read-only), `--compile --engine <...>`, `--check`, `--import`/`--export --to managed-agents`, `--export --to managed-agents --deploy [--execute]` (originate + publish a local definition to Managed Agents), `--export --to outcome-gate` (stdout-only unreviewed manual draft), `--check-findings -` (stdin-only committed-location check), `--convert --to <toml|yaml|json>`.

    Baseline exported help · 11249a60

    List .claude/agents/*.md across registered projects; `agents <project> --rename <old> --to <new>` renames a subagent (e.g. the Commander orchestrator); `--create`/`--edit`/`--delete <name>` author one (the Agents-center backend).

    Additionally reviewed CLI source 61d89aeb lists editable .claude/agents/*.md and read-only .github/agents/*.agent.md; --show reads either set, and a same-name editable definition takes listing precedence. Previous baseline 11249a60; the current source review is shown above. The installed-build behavior is not certified.

  • commandem analyze

    Analyze an image or a running dev-server URL (screenshotted via headless Chrome) with claude. --against <design> = verify an implementation against its mockup.

  • commandem approvals

    List pending tool approvals across all live chats (cross-project inbox).

  • commandem approve-tool

    Allow or deny a pending tool approval (from `commandem approvals`).

  • commandem assist

    Request orchestrator help from inside a project: stages a plan-only help run for owner approval + posts a board note (no run starts; the enqueue safety class). See also: enqueue, handoff, board.

  • commandem audit

    Committee audit: fan one structured audit prompt out to a panel of independent model judges, then synthesize consensus/disagreements/unique findings. Dry-run by default; --execute spends (local/apple judges are free). See also: review, eval-codebase.

  • commandem auto-triage

    Run a diagnostic AI session on attention-bucket projects (dry-run by default).

  • commandem autopilot

    Run claude toward a goal unattended (auto-approve + auto-continue; not `ask`).

  • commandem brief-me

    Generate an AI daily briefing from your project state (reads state; not `brief`, which writes CLAUDE.md).

  • commandem cap

    Hard-floor authorization broker (phase 136): mediate a floor command an unattended run needs, authorized by a live human ceremony -- the wall stays whole, this is a door beside it.

  • commandem commit

    Draft a Conventional Commits message from the staged diff (local model first).

  • commandem conduct

    Multi-agent conductor: LLM-decompose ONE goal into tailored per-project tasks, dispatch each as an isolated autopilot run, integrate a review (not `orchestrate`'s verbatim broadcast).

  • commandem design

    Stage an implement-this-design task from a Figma link, a claude.ai artifact link, or a local mockup (design->code intake; plan-only). See also: enqueue, conduct, analyze.

  • commandem enqueue

    Queue a cross-project agent task (state-only; no run). --tag/--group queue for a whole set.

  • commandem eval-codebase

    Send a codebase summary to an LLM for independent quality assessment (dry-run by default).

  • commandem evidence

    Export one run's lifecycle, receipt, diffstat, policy decisions, and A2A events as a reviewable JSON bundle.

  • commandem experiment

    Inspect the cross-project experiment lifecycle ledger or statistical results without running models or hooks.

  • commandem fleet

    Register remote Outpost nodes or Managed Agents surfaces and see their agent runs in `commandem queue` (fleet aggregation; add/ls/rm). For local agent/model/account bindings, see `roles`, `account`, `provider`, or `model` instead.

  • commandem handoff

    Hand a task from this project (cwd, or --from) to another: stages an unattended run on the target with the origin's context attached AND posts a board handoff note. Pull-based (nothing runs until the runner). See also: enqueue, tell, board.

  • commandem hooks

    Install, inspect, or remove Commandem token tiering for raw Claude sessions.

  • commandem issue

    Enqueue a task from a GitHub issue (or failing CI run). Fetches title+body via gh, queues an AgentRun.

  • commandem kill

    Hard kill the agent runtime + drop a cross-process stop sentinel.

  • commandem measure

    Measure whether injected context (directives, recipes, memory seeds, or this project's full brief) changes agent behavior: with/without A/B, deterministic checkers.

  • commandem model

    Show or switch the LOCAL model (auto-discovers ollama / LM Studio / vLLM; persists for the CLI + app).

  • commandem nudge

    Auto-continue a STALLED session commandem OWNS (bounded + killable). Refuses an external session (adopt via `commandem chat`). See `commandem stalled`.

  • commandem op

    Propose, authorize, dispatch, and track a quota-sized, dependency-ordered OPERATION of roadmap work (Mission 850).

  • commandem orchestrate

    Bounded parallel fan-out: run independent sub-tasks concurrently, each an isolated autopilot run (deliberate, not a swarm). Or broadcast one --goal ACROSS projects with --all/--group/--tag.

  • commandem policy

    Fleet policy: editable never/ask-first/allowed command rules across every repo + agent. All tiers editable (incl. floor lifts via unsafe-allow); lifts are disclosed, never silent. `grants` lists the human-approved exact-operation grants the approval cards save (shared across compatible agents).

  • commandem post-commit

    Capture a lesson from the latest git commit (runs as a .git/hooks/post-commit script).

  • commandem pr

    Act on a GitHub PR (diff/view/approve/request-changes/comment/merge) via gh.

  • commandem queue

    List queued/in-flight/finished runner runs.

  • commandem recall

    Search memory across every project (the cross-project moat).

  • commandem remember

    Record a cross-project lesson from a project (decision/mistake/pattern/fix).

  • commandem retry

    Stage a new queued run from one failed or killed local AgentRun; preserves its dispatch and verify contract.

  • commandem review

    AI code review of uncommitted changes, a PR (--pr N), or a range (dry-run by default).

  • commandem roles

    Show or set role bindings and task preferences (manifest > global > default).

  • commandem route

    Pick the best available model for a task (the inspectable side of --model auto).

  • commandem runner

    Opt-in PLAN-ONLY unattended agent loop draining the queue (not `run`).

  • commandem saturate

    Quota-maximizing worker: propose (and --stage plan-only) roadmap-derived agent work sized to your UNUSED weekly Claude allowance. Dry-run by default; nothing runs until `commandem runner`. See also: enqueue, runner, usage.

  • commandem skills

    List .claude/skills across projects + user level; `skills new <name> [<pattern>]` scaffolds a SKILL.md + eval.toml; `skills install <name|dir|proj:name>` installs a builtin/published/fleet skill; `skills search`/`skills publish <dir>` use the marketplace.

  • commandem suggest

    Suggest your next chat message from a project's own tracked conversations (retrieval; --generate for a local model; --reply for smart-replies to the agent's last message).

  • commandem swarm

    Inspect and control a bounded swarm of worker runs.

  • commandem tell

    Post a note to another project on the message board (pull-based; never triggers a run).

  • commandem transition

    Resolve a provider-neutral chat transition, review or seal a Matrix bridge at a request boundary, offer a reviewed quota handback, or record delivered-bridge outcome and relationship feedback.

  • commandem account

    Manage native login and isolated account profiles for supported agents.

  • commandem backup

    Export all commandem state to a portable tar.gz archive (or restore from one).

  • commandem claude-check

    Check the claude CLI version vs latest; --install an hourly notifier.

  • commandem clis

    Daily health checkup of the CLIs commandem drives (claude/codex/gemini/gh): version drift + auth state.

  • commandem daemon

    Foreground check-runner loop (launchd-managed in production).

  • commandem env

    Manage per-directory trust for a cwd .env (direnv-style): a ./.env loads only after you --allow this dir.

  • commandem focus

    Start a focus session on a project (default 25m Pomodoro).

  • commandem man

    Generate a groff man page (commandem.1) for the command surface. --json emits the verb tree instead.

  • commandem prefs

    Get or set global commandem preferences (e.g. default_mode).

  • commandem reminders

    List snoozes/focus; --include-owned lists agent reminders; Project --add creates one; --disable cancels.

  • commandem setup

    Read-only agent-profile inventory, or opt-in infra status with --only gh|wrangler|notion|linear. Other kinds and interactive setup are not implemented. See account, doctor --deps, clis and provider.

  • commandem statusline

    Claude Code statusLine provider: caches REAL subscription usage (rate_limits) + prints a status line. Set in ~/.claude/settings.json.

  • commandem update

    Explicit self-update via go install @latest (never automatic).

  • commandem version

    Print the build-stamped version; --check notifies if newer.

  • commandem ack

    Mute a project (or one of its failing checks) from the attention bucket until its state changes.

  • commandem announce

    Stage an operator note for asynchronous delivery into LIVE chat sessions; inspect the durable outcome with --history.

  • commandem approve

    Execute the plan a prior `ask` stored, runner-awaiting runs, or a Managed Agents tool confirmation.

  • commandem ask

    Run a headless claude agent in --mode plan (dry-run) by default.

  • commandem chat

    Live bidirectional agent proxy as NDJSON (claude default; --agent codex|gemini|antigravity|goose for a resume-per-turn session).

  • commandem check

    Run a project's check_command on demand (or --tag/--group to run a whole set).

  • commandem deploy

    Run the pre-deploy readiness gate (git clean, tests, health), then the project's deploy_command.

  • commandem deployment

    Managed Deployments (hosted cron) for a linked Managed Agent: ls|show|create|pause|resume|rm. D5 guardrails: both a per-run AND a daily budget cap are required to create one; create/pause/resume/rm are refused inside an unattended run or a plugin; create is dry-run until --execute; rm ARCHIVES (there is no delete).

  • commandem exec

    Run a shell command across projects in parallel and aggregate the output (the cross-project broadcast console). Or `exec <pattern> "<cmd>"`.

  • commandem next

    Dequeue + start the next queue_file entry for a project.

  • commandem open

    Open a project in a coding agent (claude default), VS Code, Terminal, or Pathem. From inside tmux, opens a new tmux window instead of Terminal.app.

  • commandem pull

    Run git pull across all (or one) registered project(s).

  • commandem rewind

    Branch a chat session rewound to before message N (edit/rewind engine).

  • commandem run

    Start a project's run_command (detached, in its own process group; not `runner`, the agent loop).

  • commandem snooze

    Defer a project from the attention bucket for a duration.

  • commandem steer

    Message a project's RUNNING autopilot: the note rides its next turn, marked [operator].

  • commandem stop

    Stop a project's running command (by process_pattern).

  • commandem activity

    Cross-project activity feed: commits, agent runs, check transitions, deploys (newest first). Optional <pattern> scopes to one project; --news-json requires an exact registered name.

  • commandem board

    Read the cross-project message board (all, or one project's thread + what it's working on).

  • commandem chatsearch

    Full-text search across every project's Claude conversation transcripts (vs `search`'s code grep).

  • commandem codescan

    Scan projects' source CONTENT for dangerous patterns (eval/exec injection, unsafe deserialization, shell injection, XSS sinks, disabled TLS verification, weak crypto, hardcoded credentials). Critical/high findings raise attention.

  • commandem comment

    Comment on a durable local target thread, configure its destination default, migrate legacy Notes/comments, or comment on a legacy activity-feed event.

  • commandem complexity

    Score a task's difficulty (free, deterministic) + suggest a lighter claude model/effort for simple work.

  • commandem config

    List or show a project's claude config files.

  • commandem context

    Semantic retrieval over ONE project's code/docs (relevance-ranked; vs `search`'s exact grep).

  • commandem context-inspect

    Inspect the bounded, redacted context manifest captured at one model-request boundary.

  • commandem cost

    Provider/Profile reported run cost plus separately labelled Claude transcript list-price estimates.

  • commandem deps

    Show which registered projects depend on each other.

  • commandem diff

    Show uncommitted changes across all (or one) registered project(s).

  • commandem digest

    Weekly work summary across registered projects (workbenches hidden by default).

  • commandem gate

    Catalog, draft, inspect, validate, resolve, or preflight an evidence-backed Gate contract without running an agent.

  • commandem gitguard

    Watch registered repos' git metadata (config + indexes); log each change with a key diff + process snapshot.

  • commandem history

    Tail polaris's check transition log (history.jsonl).

  • commandem inbox

    Unified review inbox: ONE urgency-ranked list of everything fleet-wide that needs you (tool approvals, agent plans, killed/failed/worktree runs, PRs awaiting review).

  • commandem limits

    Show exhaustion, near-limit preparation, and handback rules with each field's source; simulate a quota window or set scoped JSON on stdin.

  • commandem links

    Run each project's links_check_command + report broken links (--install schedules it).

  • commandem log

    Tail the most recent log file for a project.

  • commandem metrics

    Report local, content-free lifecycle coverage, export a redacted diagnostic bundle, or derive read-only Plan/Week outcomes.

  • commandem monitor

    HTTP health checks against projects with health_url configured.

  • commandem observe

    Concurrent operational snapshot for the Monitor workspace: runs, approvals, fleet, capacity, health, notifications, and receipts.

  • commandem plan

    Cross-project planning snapshot: roadmaps, Week commitments, needs-you work, and provider capacity.

  • commandem pressure

    Machine compute pressure: load, memory, heaviest processes (attributed to projects). The "why is it laggy?" answer.

  • commandem privacy

    Inspect project privacy policy, run a bounded local sensitivity scan, or preview a Profile-aware data-use decision without launching.

  • commandem projects

    List all projects in polaris's registry.

  • commandem replay

    Reconstruct one run's bounded causal timeline from durable runs, transcripts, policy, gates, limits, and receipts.

  • commandem repos

    Cross-project git-state rollup: which repos are dirty, ahead/behind origin, or carry extra branches. Parallel; read-only.

  • commandem reviews

    Show GitHub PRs awaiting your review across all (or one) registered project(s).

  • commandem screenshots

    List recent screenshots, or --watch for new ones to analyze.

  • commandem search

    git grep across every registered project, in parallel. With --in and --replace, preview a literal cross-file replacement; --apply requires the preview hash.

  • commandem sessions

    List sessions for a project; --agent selects Claude, Codex, Gemini, or Local; --view tails one.

  • commandem stalled

    List stuck sessions across providers and Profiles; owned ones can `commandem nudge`, external ones adopt through the reported provider identity.

  • commandem stash

    Show git stashes across all (or one) registered project(s).

  • commandem stats

    Per-project stats: messages, tokens, git commits/files.

  • commandem status

    Cross-project status (sources: registry + git + gh + claude). Optional pattern scopes the result; --since shows what changed.

  • commandem stream

    Long-lived NDJSON stream of status snapshots + attention deltas.

  • commandem time

    Estimated time per project from git commit clustering.

  • commandem tokens

    Provider/Profile reported run tokens plus Claude archive session/model analysis with estimated list-price cost.

  • commandem trace

    Trace one provider-owned session with explicit message, tool, and result fidelity.

  • commandem ui

    Interactive terminal UI (SSH-friendly); live status + dispatch.

  • commandem usage

    Aggregate Claude usage across projects. Set ANTHROPIC_ADMIN_KEY to also report ground-truth API tokens + billed cost from a Console org.

  • commandem vulns

    Scan projects' declared dependencies for known vulnerabilities via OSV-Scanner (route, never rebuild). Critical/high findings raise attention (--install schedules it).

  • commandem waste

    Flag Claude sessions with model-tier overspend (model OUTRANKS what the router would pick) or a low cache-hit rate (below what the session's turn count should plausibly achieve). Observation-only; high-confidence by default, --all adds medium. See `tokens`/`route`.

  • commandem week

    One concurrent weekly snapshot: needs-you inbox, roadmap candidates, verified completions, reminders, usage, and digest.

  • commandem acp

    Manage declared custom ACP (Agent Client Protocol) CLI profiles: ls|add|rm. A saved profile routes as `--agent acp:<name>` for `chat`, `autopilot`, and `open` (acp_agents.toml; see docs/acp-agents.md).

  • commandem add

    Add a project to polaris's central registry from its commandem.toml.

  • commandem adopt

    Adopt an existing repo (e.g. one teleported from a claude.ai/code web session) as a tracked project, seeding a roadmap from its conversation.

  • commandem archive

    Archive a project (hide from status); --restore to un-archive; --list to show archived.

  • commandem bisect

    Automated git bisect run for a registered project.

  • commandem brief

    Sync polaris-awareness + standing directives into every project's CLAUDE.md (writes files; not `brief-me`).

  • commandem doctor

    Audit registry state; --deps preflights tools and --missions migrates legacy Mission references.

  • commandem group

    Manage first-class project groups (named collections of projects).

  • commandem health

    Audit engineering hygiene across registered projects.

  • commandem icon

    Set a project's avatar emoji (or --clear for the monogram).

  • commandem import

    Bootstrap commandem from your claude history: register every project you've used claude in.

  • commandem init

    Scaffold a commandem.toml manifest in the current dir.

  • commandem manifest

    Show or edit a project's commandem.toml convention fields (comment-preserving).

  • commandem migrate

    Import beacon's project registry into polaris's.

  • commandem new

    Create a documents, simple, blank, or coding workspace, or use a GitHub template repo.

  • commandem notes

    Per-project scratchpad: append, show, or clear timestamped notes.

  • commandem onboard

    Configure the standard directive modules (privacy/secrets/finish/commit) that `brief` propagates.

  • commandem persona

    Security personas: bundle directives + policy floor + autonomy into one posture.

  • commandem provider

    Manage named LLM API profiles: ls|add|rm|discover|test|export|import. Bundles contain credential references, never secret values; import diagnoses missing local credentials without erasing existing references.

  • commandem recipe

    Reusable prompt library: render a curated/your-own template with project context; search/install/publish to a registry.

  • commandem redact

    Mask likely secrets (API keys, tokens, private keys) in stdin -> stdout.

  • commandem registry

    Run the self-hostable artifact registry (serve) or moderate submissions (queue/approve/reject/rekey).

  • commandem remove

    Un-track a project from polaris's registry (in-repo commandem.toml kept).

  • commandem rename

    Rename a registered project (roadmap + comments preserved; groups + ack/snooze state migrated).

  • commandem roadmap

    Show or edit a project's roadmap: its Campaigns and the Missions that support them.

  • commandem scan

    Scan a directory tree for git repos and register them in bulk.

  • commandem smartgroup

    Filter-defined project groups: named expressions over snapshot fields (dirty, attention, tag:client, ahead>2) every shell renders as a sidebar section.

  • commandem tag

    Edit a project's tags in the registry index.

  • commandem tags

    List all tags in use across registered projects with counts.

  • commandem theme

    Full-palette theme engine: import a VS Code theme .json; the app applies it.

  • commandem vscode

    Scaffold .vscode/tasks.json with polaris/claude tasks.

  • commandem workbench

    Durable per-agent git worktrees: concurrent agents WITHOUT long-lived branches (`land` returns each branch to trunk; `prune` removes idle ones).

  • commandem workspace

    Purpose-scoped workspaces: while one is ACTIVE, every surface (status/sidebar/stream/menubar) shows ONLY its projects -- a scoped instance without a separate registry. `--all-workspaces` (any verb) bypasses. See also: group, smartgroup.

  • commandem automations

    Versioned triggers, schedules, effects, quota posture, and exact-revision history.

  • commandem control

    HTTP control surface (loopback-only, bearer-token, read-only verbs).

  • commandem mcp

    Attach ANY MCP server to a project (`mcp add|ls|rm <project>`), search the official MCP registry (`mcp search <query>`), or run commandem's own MCP server over stdio (bare; --install-desktop wires Claude Desktop).

  • commandem node

    Run the Outpost: this binary headless on your own always-on box (VPS/home server) -- hosts web + runner, clones repos, BYO subscription. Works with your Mac closed.

  • commandem notify

    Watch the attention bucket and send macOS notifications.

  • commandem pair

    Pair a phone with the web surface: print a QR + one-time code that mints a per-device revocable token.

  • commandem plugins

    List installed plugins, or browse/install/publish community plugins via a registry.

  • commandem slack

    Post attention-bucket changes to Slack via Incoming Webhook.

  • commandem sync

    Sync status to notion/linear, or inspect provider-neutral planning and collaboration sync.

  • commandem sync-state

    Sync commandem state across machines via iCloud Drive.

  • commandem triggers

    Declarative reactions to attention events (notify/slack/enqueue; dry-run unless --watch).

  • commandem web

    Serve a mobile-responsive web dashboard for project status and dispatch.

  • commandem webhook

    Receive GitHub webhook POSTs and invalidate project cache on events.

Glossary (18)
  • Project

    A registered working directory plus its manifest, roadmap and local state. Registration is not repository publication.

  • Workspace

    A named project grouping/scope filter. It does not save a split-pane layout or copy a chat.

  • Workbench

    An agent-isolated Git working tree; reviewed changes land into the primary integration checkout.

  • Saved View

    A stored layout/pane configuration, optionally selected as a project default. Not an archive of conversation messages.

  • Profile

    Reusable provider/account-related configuration. A native account owns its authentication/session root; an endpoint profile is a different configuration.

  • Loadout

    Reusable routing, role, account-reference and behavior choices. Credentials stay in provider-owned or protected local storage.

  • Campaign

    A grouping of related outcomes and Missions. It is not a provider-specific chat session.

  • Mission

    A durable identified unit of roadmap work, with executable tasks, dependency state and completion evidence.

  • Gate

    A named check whose observed evidence constrains an action. A passing check proves only its tested contract.

  • Receipt

    A durable record of a run's identity, result and available verification evidence; not a guarantee of successful implementation.

  • Handoff

    Reviewed context delivery to a destination conversation. Cross-provider handoff is different from native resume.

  • Context manifest

    Provenance/accounting for included, excluded and truncated sources; not a model attention trace.

  • Matrix

    The conversation relationship/context surface. Deterministic retrieval is not a trained graph neural network.

  • GNN

    A learned graph model requiring qualified data, topology and held-out evaluation. A training pipeline alone does not qualify a deployed model.

  • Incognito

    A local retention/session posture with provider-specific limits, separate from provider training policy.

  • Advisory

    Evidence or a suggestion from another agent, not an owner-authorized instruction or tool approval.

  • Reported versus estimated usage

    Provider-reported quota, observed exhaustion and local cost/token estimates are separate evidence types. Unknown is not zero.

  • Infrastructure outcome

    A transport, dependency, host or harness failure. It is not an adjudicated model result and must be reported separately.

Feature reference, not another tutorial

Choose a chapter when you need to know what a feature does, where to find it, which scope it changes and what it cannot prove. Use the workflow guides for step-by-step tasks, Troubleshooting for recovery, Capabilities for provider limits and Research for dated experimental evidence.

Workspaces and Home

Choose the right surface for global status, investigation and action.

Project tabs

A complete map of the selected project's sixteen tabs.

Planning and execution

Connect plans to bounded runs, reviewable gates and durable receipts.

History, context and handoffs

Use prior work without blurring native resume, retrieval and privacy boundaries.

Profiles, Loadouts and privacy

Make identity, configuration and data-use posture explicit before dispatch.

Collaboration and extensions

Know where shared content lives and what an integration is allowed to do.

Navigation, Saved Views and shortcuts

Separate project scope, pane layout and agent-isolation worktrees.

Settings reference

All twelve categories, direct access routes, persistence scopes and safety boundaries.

Controls and source defaults

Exact static Settings labels and code initializers, with configuration context, not private user values.

CLI command reference

All 168 visible commands from man --json, grouped by purpose, with scope and execution cautions.

Reviewed coverage and its limits

This edition accounts for 336 declared app surfaces: 16 project tabs, 12 Settings categories, seven named product workspaces, 17 Home widgets, five sidebar destinations, eight configurable shortcuts, 30 static palette entries, 160 static control labels, 78 stored-preference initializers and three conversation styles. The CLI index covers 168 visible commands from man --json.

Coverage compares exact source identifiers and evidence with real chapter anchors. Additions, removals or changed declarations require a reviewed documentation change. Source-freshness checks also bind the selected files to this dated source review. Counts do not prove runtime correctness, all contextual actions, dynamic names, every provider sign-in or physical-device behavior. Unsupported and unknown capabilities remain visible as limits rather than being omitted.

Product vocabulary

These terms name distinct scopes. They are not interchangeable: saving a layout does not migrate sessions, and a profile name does not grant authority.

Project
A registered working directory plus its manifest, roadmap and local state. Registration is not repository publication.
Workspace
A named project grouping/scope filter. It does not save a split-pane layout or copy a chat.
Workbench
An agent-isolated Git working tree; reviewed changes land into the primary integration checkout.
Saved View
A stored layout/pane configuration, optionally selected as a project default. Not an archive of conversation messages.
Profile
Reusable provider/account-related configuration. A native account owns its authentication/session root; an endpoint profile is a different configuration.
Loadout
Reusable routing, role, account-reference and behavior choices. Credentials stay in provider-owned or protected local storage.
Campaign
A grouping of related outcomes and Missions. It is not a provider-specific chat session.
Mission
A durable identified unit of roadmap work, with executable tasks, dependency state and completion evidence.
Gate
A named check whose observed evidence constrains an action. A passing check proves only its tested contract.
Receipt
A durable record of a run's identity, result and available verification evidence; not a guarantee of successful implementation.
Handoff
Reviewed context delivery to a destination conversation. Cross-provider handoff is different from native resume.
Context manifest
Provenance/accounting for included, excluded and truncated sources; not a model attention trace.
Matrix
The conversation relationship/context surface. Deterministic retrieval is not a trained graph neural network.
GNN
A learned graph model requiring qualified data, topology and held-out evaluation. A training pipeline alone does not qualify a deployed model.
Incognito
A local retention/session posture with provider-specific limits, separate from provider training policy.
Advisory
Evidence or a suggestion from another agent, not an owner-authorized instruction or tool approval.
Reported versus estimated usage
Provider-reported quota, observed exhaustion and local cost/token estimates are separate evidence types. Unknown is not zero.
Infrastructure outcome
A transport, dependency, host or harness failure. It is not an adjudicated model result and must be reported separately.

Documentation quality bar

Keep conceptual explanation, exact source defaults, provider limits and workflows linked. New declared features must receive a real documentation target before the site gate passes. A source review expires after 30 days and changed reviewed contracts require review sooner. Automated tests cannot replace screen-reader or physical-device acceptance.

This website documents the pre-release product. Public source, app artifacts and support channels require separate approval; this reference does not claim they have shipped.