Project commands

These commands use physics-inspired names (nucleate, evolve, decay, spore, …). New to the vocabulary? See The physics vocabulary.

cs init

Bootstrap a project-local .cosmon/ directory (creates the target dir if missing)

Usage: cs init [OPTIONS] [PATH]

EXAMPLES: cs init # bootstrap .cosmon/ in the current directory cs init ./new-galaxy # create ./new-galaxy/, then populate .cosmon/ cs init --soft # generate only CLAUDE.md (no .cosmon/) cs init --soft --template rust # Rust-specific conventions cs init --soft --template data # data/research conventions cs init --upgrade # backfill missing canonical formulas

Creates .cosmon/{config.toml, state/, formulas/, …}. The target path may not exist — cs init runs mkdir -p before populating. Running twice on the same path is a strict no-op.

Does NOT run git init (that is git's job) and does NOT write CLAUDE.md by default — pass --soft to generate an agent template. Refuses to nest: if an ancestor already carries .cosmon/, exits non-zero — no --force.

On a terminal, the first cs init of your life also asks the one-time developer-share question (deny-by-default, cs opt-in-share --status to review). Never asked under --json, never asked when stdout is captured.

Symmetric undo: rm -rf <path>/.cosmon/.

Arguments:

• <PATH> — Directory to initialize (default: current directory).

  Need not exist. If it does not, cs init creates it with mkdir -p. If it exists and already contains .cosmon/, the command is a no-op (strict idempotency).

  Default value: .

Options:

• --upgrade — Upgrade an existing .cosmon/ project by backfilling missing canonical formulas AND project_id without overwriting existing files

• --soft — Generate only a minimal CLAUDE.md (≤50 lines) without creating .cosmon/.

  Constitutional projection: conventions propagated via a single file that any agent can read independently. No orchestration infrastructure, no runtime state, no external dependency.

• --template <TEMPLATE> — Project-type template for --soft (default: generic)

  Default value: generic

  Possible values:

  • generic: Generic project — language-agnostic conventions
  • rust: Rust project — cargo-based conventions
  • data: Data/research project — notebook + pipeline conventions

• -y, --yes — Assume "yes" to any confirmation prompt (non-interactive mode).

  cs init is already fully non-interactive today, so this flag is accepted and ignored. It is reserved so that README quickstarts (cs init --yes) stay paste-testable if prompts are ever added — per the knuth paste-testability invariant and tolnay's semver rule that reserving a flag now makes adding prompts later a non-breaking elaboration.

• --tenant <NOYAU> — Tenant (noyau) this galaxy belongs to. Records the ADR-063 layer-3 label in config.toml and provisions the .cosmon/state/nucleons/ directory where ADR-080 OIDC identity mappings (oidc-identity.toml) and future YubiKey keyring entries land.

  Convention: one tenant per galaxy below the configured cluster root. This flag records the label but does not enforce a path. Downstream tools read the noyau to verify the galaxy belongs to its tenant.

cs trust

Trust — grant this repository permission to run its own formulas/hooks (the direnv allow of cosmon; refuses repo-supplied shell until granted)

Usage: cs trust [OPTIONS]

Options:

• --status — Report the current trust status without changing anything
• --revoke — Revoke this repository's trust grant
• --dir <DIR> — Operate on this directory instead of the current working directory

cs config

Config — inspect .cosmon/config.toml (show adapters, adapters)

Usage: cs config <COMMAND>

Subcommands:

• show — Show resolved configuration for a topic (currently: adapters)
• adapters — List every adapter name the dispatch registry would accept (union of compile-time built-ins and [adapters.<name>] rows from .cosmon/config.toml)

cs config show

Show resolved configuration for a topic (currently: adapters)

Usage: cs config show <COMMAND>

Subcommands:

• adapters — Print the effective [adapters.*] resolution for Direct-API adapters (openai, anthropic)

cs config show adapters

Print the effective [adapters.*] resolution for Direct-API adapters (openai, anthropic)

Usage: cs config show adapters

cs config adapters

List every adapter name the dispatch registry would accept (union of compile-time built-ins and [adapters.<name>] rows from .cosmon/config.toml)

Usage: cs config adapters

cs status

Project pulse — quick DAG overview like git status

Usage: cs status

EXAMPLES: cs status # pulse: active / pending / blocked / completed cs status --fleet research cs status --json # includes galaxies block (by-kind + nascent)

SEE ALSO: cs peek (fractal TUI), cs ensemble (full snapshot), cs galaxies list (four-family taxonomy).

cs project

Project — materialize views from the ledger (STATUS.md, ISSUES.md, GitHub Issues)

Usage: cs project [OPTIONS]

EXAMPLES: cs project # materialize surfaces from the ledger cs project --check # dry-run; exit 1 if surfaces are stale cs project --fetch # pull current GitHub Issue state before comparing

Pure projection. Writes STATUS.md / ISSUES.md / GitHub issues per .cosmon/surfaces.toml. Always safe to rerun. Reads as "materialize views from the ledger" (ADR-052 §D3).

Options:

• --check — Dry-run: check if surfaces are up to date without writing

• --fetch — Fetch current GitHub Issue state before comparing (detect remote edits)

• --force — Deprecated no-op. Surfaces are always overwritten from authoritative state (derived-view semantics), so there is no longer a non-force mode to override. Accepted for backward compatibility

• --no-escalate — Deprecated no-op. Surface conflicts no longer escalate or write git-style conflict blocks — surfaces are derived views and are always regenerated. Accepted for backward compatibility

• --wait — Deprecated no-op. Reconcile never nucleates resolver molecules, so there is nothing to wait for. Accepted for backward compatibility

• --heal-invariants — Heal the archived ⇒ status.is_terminal() invariant on disk.

  Default reconcile is a pure projection onto surfaces and never mutates molecule state (architectural-invariants.md). This flag opts into a one-shot migration: every molecule that is archived but carries a non-terminal status (a ghost, e.g. {archived: true, status: running}) is rewritten to status = Collapsed with reason archived-but-alive heal, and a MoleculeStatusChanged + MoleculeCollapsed event pair is appended so the heal survives a cache rebuild from events.jsonl.

  Idempotent: once healed, a second --heal-invariants pass finds nothing to do. Detect the violations first with cs verify --invariants.

cs reconcile

Reconcile — deprecated alias for cs project (ADR-052 §D3)

Usage: cs reconcile [OPTIONS]

EXAMPLES: cs reconcile # DEPRECATED — see below

DEPRECATED (ADR-052 §D3): use cs project instead. The new verb reads as "materialize views from the ledger"; reconcile read as "patch something that drifted", which is the framing ADR-052 retires. This alias will be removed after one release cycle.

SEE ALSO: cs project (canonical).

Options:

• --check — Dry-run: check if surfaces are up to date without writing

• --fetch — Fetch current GitHub Issue state before comparing (detect remote edits)

• --force — Deprecated no-op. Surfaces are always overwritten from authoritative state (derived-view semantics), so there is no longer a non-force mode to override. Accepted for backward compatibility

• --no-escalate — Deprecated no-op. Surface conflicts no longer escalate or write git-style conflict blocks — surfaces are derived views and are always regenerated. Accepted for backward compatibility

• --wait — Deprecated no-op. Reconcile never nucleates resolver molecules, so there is nothing to wait for. Accepted for backward compatibility

• --heal-invariants — Heal the archived ⇒ status.is_terminal() invariant on disk.

  Default reconcile is a pure projection onto surfaces and never mutates molecule state (architectural-invariants.md). This flag opts into a one-shot migration: every molecule that is archived but carries a non-terminal status (a ghost, e.g. {archived: true, status: running}) is rewritten to status = Collapsed with reason archived-but-alive heal, and a MoleculeStatusChanged + MoleculeCollapsed event pair is appended so the heal survives a cache rebuild from events.jsonl.

  Idempotent: once healed, a second --heal-invariants pass finds nothing to do. Detect the violations first with cs verify --invariants.

cs scheduler

Scheduler — read-only view onto cosmon-scheduler's state (patrols, last fires, log)

Usage: cs scheduler <COMMAND>

IMAGE: cosmon-scheduler is the house's alarm clock. It looks at the wall clock every 60s, reads its tablet (~/.config/cosmon/patrols.toml), and asks: 'was anything supposed to ring now?'. If yes, it fires a short-lived command, the command finishes, it dies. Cron-like.

(See the seven-clocks chronicle and the '2026-04-19 — Deux métiers, deux outils' chronicle for the full réveil/veilleur-de-nuit image.)

WHEN TO USE THE SCHEDULER:

• periodic gesture, short burst (executor-pulse every 2h, mailroom-sync every 15min, chronicle-lint every Sunday morning)
• fire-and-forget: the command finishes on its own
• no persistent connection to maintain If the command must stay alive between fires, use cs daemons instead.

EXAMPLES — operator-facing (cs scheduler): cs scheduler status # pretty table of patrol last-fires cs scheduler status --json # NDJSON, one object per patrol cs scheduler status --log-lines 20 # also tail last 20 log lines cs scheduler status --state-file /tmp/state.json cs scheduler validate # lint ~/.config/cosmon/patrols.toml cs scheduler validate --config cand.toml # pre-flight a candidate file

CARDINAL PATROLS (copy-ready reference): docs/guides/patrols-cardinal.md cosmon-ward-mayor, reading-club-tick, leaks-watchdog, backlog-frontier-rot, digest-personnel — one [[patrol]] block each.

MINIMAL patrols.toml (/.config/cosmon/patrols.toml): [scheduler] state_file = "/.cosmon/scheduler.state.json" log_file = "/.cosmon/scheduler.log" kill_switch = "/.cosmon/stand-down.lock" tick_interval_seconds = 60

[[patrol]] name = "executor-pulse" interval_seconds = 7200 # cadence: every 2h command = ["mailroom", "executor-pulse"] enabled = true

[[patrol]] name = "chronicle-lint-weekly" cron = "0 9 * * 0" # cadence: Sundays 09:00 command = ["cs", "nucleate", "chronicle-lint"] working_dir = "~/galaxies/example-project" enabled = true

HOT-RELOAD: The scheduler re-reads patrols.toml on every tick (default 60s). Edit the file, save it, and the change takes effect within one tick — no signal, no reload command. Add a patrol = it fires on the next tick; disable one = it stops.

KILL-SWITCH: touch ~/.cosmon/stand-down.lock — the scheduler observes the lock at the next tick and quietly skips every patrol until the file is removed. No child is killed; already-firing patrols finish on their own. Same lock convention as cs daemons (one lockfile silences both worlds).

SEE ALSO: cs daemons (long-running processes), ADR-050 (unified patrol scheduler).

Subcommands:

• status — Show the last-known state of every patrol the scheduler has observed
• validate — Lint patrols.toml without firing anything — the safe pre-flight when adding or editing a patrol (success criterion (i) of the autopilot primitive). Zero side-effects: no state read, no dispatch, no kill-switch touch. Exits 0 when the file parses and validates, 1 otherwise — so it doubles as a CI gate. Mirrors cosmon-scheduler validate

cs scheduler status

Show the last-known state of every patrol the scheduler has observed

Usage: cs scheduler status [OPTIONS]

Options:

• --state-file <PATH> — Path to the scheduler state file
• --log-file <PATH> — Path to the aggregate scheduler log
• --log-lines <N> — Tail the last N lines of the scheduler log after the status table. Omit the flag for no log output

cs scheduler validate

Lint patrols.toml without firing anything — the safe pre-flight when adding or editing a patrol (success criterion (i) of the autopilot primitive). Zero side-effects: no state read, no dispatch, no kill-switch touch. Exits 0 when the file parses and validates, 1 otherwise — so it doubles as a CI gate. Mirrors cosmon-scheduler validate

Usage: cs scheduler validate [OPTIONS]

Options:

• --config <PATH> — Path to the patrol config TOML to lint

cs daemons

Daemons — operator view over cosmon-daemon-supervisor (list/status/reload/logs)

Usage: cs daemons <COMMAND>

IMAGE: cosmon-daemon-supervisor is the night watchman. It does not look at the clock. It looks at the dogs — processes that must always be alive. It reads its tablet (~/.config/cosmon/daemons.toml), keeps each dog alive; if one dies, it calls it back. Dogs never die voluntarily; if they die, it is an accident.

(See the '2026-04-19 — Le gardien des chiens, et le gardien des portes' and '2026-04-19 — Deux métiers, deux outils' chronicles for the full gardien-de-chiens / veilleur-de-nuit image.)

WHEN TO USE THE SUPERVISOR:

• long-running process, persistent connection (Telegram long-polling, IMAP IDLE, MCP stdio server, Emacs daemon)
• must be restarted if it dies
• throttle respawns to avoid crashloops Synthetic examples: notification-bot, archive-service, editor-daemon, metrics-dashboard. If the command should run once-and-exit on a cadence, use cs scheduler instead.

EXAMPLES — operator-facing (cs daemons): cs daemons list # declared daemons (from daemons.toml) cs daemons status # per-daemon status + last spawn age cs daemons status --json # NDJSON, one object per daemon cs daemons reload # touch config → supervisor hot-reload cs daemons logs --lines 100 # tail the supervisor aggregate log

MINIMAL daemons.toml (/.config/cosmon/daemons.toml): [supervisor] state_file = "/.cosmon/daemon-supervisor.state.json" log_file = "/.cosmon/daemon-supervisor.log" kill_switch = "/.cosmon/stand-down.lock"

[[daemon]] name = "notification-bot" binary = "/.local/bin/notification-bot" args = [] throttle_seconds = 30 env = { RUST_LOG = "info" } log_stdout = "/.local/state/notification-bot/stdout.log" log_stderr = "~/.local/state/notification-bot/stderr.log" enabled = true

HOT-RELOAD: cs daemons reload touches ~/.config/cosmon/daemons.toml. The supervisor's notify watcher picks up the modification, runs the diff, and restarts ONLY the daemons whose spec actually changed (debounce ~200ms). Adding a new [[daemon]] block makes that daemon appear; removing one makes it exit gracefully. No signal sent to the supervisor itself.

SUPERVISOR-OF-THE-SUPERVISOR: The supervisor itself is a long-running process — it needs its own watchman. That is launchd (macOS): scripts/install-daemon-supervisor.sh installs one LaunchAgent for the supervisor, and launchd keeps it alive. The supervisor keeps N dogs alive. One plist, N dogs.

Install the LaunchAgent: scripts/install-daemon-supervisor.sh install scripts/install-daemon-supervisor.sh status scripts/install-daemon-supervisor.sh uninstall

KILL-SWITCH: touch ~/.cosmon/stand-down.lock — the supervisor SIGTERMs every child and parks them until the file disappears. Same convention as cs scheduler (one lockfile silences both).

SEE ALSO: cs scheduler (tick-based patrols), ADR-053 (cosmon-daemon-supervisor), ADR-016 §Autonomous (the regime this lives in).

Subcommands:

• list — List declared daemons (reads daemons.toml, no state)
• status — Show current status of each supervised child (reads state.json)
• reload — Trigger a hot-reload by touching the config file
• logs — Tail the supervisor log (the aggregate one, not per-daemon stdout)

cs daemons list

List declared daemons (reads daemons.toml, no state)

Usage: cs daemons list [OPTIONS]

Options:

• --config <PATH> — Path to the daemons config file. Defaults to ~/.config/cosmon/daemons.toml

cs daemons status

Show current status of each supervised child (reads state.json)

Usage: cs daemons status [OPTIONS]

Options:

• --config <PATH> — Path to the daemons config file. Defaults to ~/.config/cosmon/daemons.toml. Used to resolve the state file
• --state-file <PATH> — Path to the supervisor state file. Overrides the state_file declared in the config

cs daemons reload

Trigger a hot-reload by touching the config file.

The supervisor's notify watcher picks up the modification and runs diff; no signal is sent and no child is restarted unless its DaemonSpec actually changed.

Usage: cs daemons reload [OPTIONS]

Options:

• --config <PATH> — Path to the daemons config file. Defaults to ~/.config/cosmon/daemons.toml

cs daemons logs

Tail the supervisor log (the aggregate one, not per-daemon stdout)

Usage: cs daemons logs [OPTIONS]

Options:

• --config <PATH> — Path to the daemons config file. Defaults to ~/.config/cosmon/daemons.toml. Used to resolve the log file

• --log-file <PATH> — Path to the supervisor log file. Overrides the log_file declared in the config

• --lines <N> — Number of trailing lines to print. Defaults to 50

  Default value: 50

cs migrate

Migrate the galaxy's memory — legacy flat→fleet, or residence-to-residence

Usage: cs migrate [OPTIONS] [COMMAND]

EXAMPLES: cs migrate # legacy flat→fleet migration (pre-residence galaxies) cs migrate to solo # atomic data+git migration to solo residence cs migrate to team # move to team residence (seal → stage → verify → flip + git-side) cs migrate to team --dry-run # seal manifest, print plan, touch no state cs migrate to solo --no-git # skip the git-side half (data only — outside a git repo) cs migrate to solo --no-commit # stage git-side changes, let operator commit cs migrate verify # re-walk state, compare against sealed manifest cs migrate rollback # inverse rename + restore git index / ignore files cs migrate rollback --dry-run # preview the rename pair, touch nothing cs migrate genre github-surface --to solo --yes # scoped: apply solo to one genre (ADR-057) cs migrate genre chronicle --to team --yes # seed orphan branch cosmon/chronicle cs migrate genre github-surface --to solo --dry-run # preview the plan, touch nothing

RESIDENCE VALUES: solo local, single operator (default layout) — state goes into .git/info/exclude team local, shared via git (cosmon-le-repo) — state goes into .gitignore encrypted local, encrypted at rest — same gitignore rule as team remote server-backed, network transport — same gitignore rule as team

EXIT CODES (cs migrate verify, mirrors cs verify): 0 manifest matches current state (A_pre ⊆ A_post, seal intact) 1 divergence: offending entries listed on stderr 2 no manifest on record (pre-migration galaxy or stale state)

The residence migration writes migration-manifest.pre.json at the galaxy root before touching any state, then stages the new tree alongside as state.next/, verifies it against the manifest, performs two atomic rename(2) calls to flip, and finally runs the git-side half: git rm -r --cached on the state directory, appends the state path to the residence's ignore file (.git/info/exclude for solo, .gitignore for team-class), and commits chore(cosmon): migrate to <residence> residence (git-side) unless --no-commit is passed. state.prev/ is kept as the rollback anchor; the pre-migration manifest also carries a snapshot of the git HEAD and ignore files so rollback restores the git side byte-for-byte. Orphan files (not tied to any molecule) are carried in a distinct bucket and never silently discarded.

Subcommands:

• to — Perform a residence migration: seal manifest → stage next tree → verify staged tree → atomic rename pair to flip
• verify — Verify the pre-migration BLAKE3 manifest against the current state. Exit codes mirror cs verify: 0 match, 1 divergence, 2 no manifest on record
• rollback — Roll back the last migration by re-materializing state.prev/
• genre — Apply a residence to every tracked path classified under a single genre (ADR-057 artifact-map). Composes artifact-map + git-side migration

Options:

• --dry-run — Legacy mode: preview what would be migrated without moving anything
• --cleanup — Legacy mode: remove the legacy ops/molecules/ directory after migration
• --archive-past — Legacy mode: backfill the archive for existing terminal molecules (Completed, Collapsed, Frozen). Idempotent: molecules already carrying archived = true are skipped

cs migrate to

Perform a residence migration: seal manifest → stage next tree → verify staged tree → atomic rename pair to flip.

Atomic data-and-git residence flip. After the data-side phases (seal → stage → verify → rename), the git-side half runs (untrack + ignore-file update + path-scoped auto-commit) unless --no-git / --no-commit opt out.

Per-residence behavior (the four places the galaxy's memory can live):

solo Writes .cosmon/ to .git/info/exclude (per-clone notebook, never pushed). Sweeps any legacy .cosmon/ / .worktrees/ lines still present in the tracked .gitignore so the shared bulletin board doesn't override the local rule. Total local invisibility (ADR-055 §3.1).

team Appends .cosmon/state/ to the tracked .gitignore (shared with the code repo) and untracks any state files previously committed. Structural files (config.toml, formulas/*.toml, surfaces.toml, .gitignore) stay trackable. Orphan-branch-backed state sharing (cosmon/state) is the cosmon-le-repo backend target.

encrypted Same gitignore footprint as team today. The age-wrap backend (requires age on PATH and a --recipient recipient key) is deferred to cosmon-le-repo.

remote Same gitignore footprint as team. The server-backed transport backend is not yet implemented.

The pre-migration manifest snapshots git HEAD + ignore files so cs migrate rollback can restore the git side byte-for-byte. Orphan files (not tied to any molecule id) are carried in a distinct bucket and never silently discarded.

Usage: cs migrate to [OPTIONS] <RESIDENCE>

Arguments:

• <RESIDENCE> — Target residence: solo, team, encrypted, or remote

  Possible values:

  • solo: Solo — local, single operator. Writes the whole .cosmon/ directory to .git/info/exclude (per-clone notebook, never pushed) and sweeps any legacy .cosmon/ / .worktrees/ lines from the tracked .gitignore (ADR-055 §3.1)
  • team: Team — local, shared across operators via git. Appends .cosmon/state/ to the tracked .gitignore (shared bulletin board) and untracks any previously committed state files. Structural files (config.toml, formulas/*.toml, surfaces.toml) stay trackable on main. Orphan-branch-based state sharing (cosmon/state) is the cosmon-le-repo backend target
  • encrypted: Encrypted — local, encrypted at rest. Same gitignore footprint as team today; the age-wrap backend (requires age on PATH and a --recipient key) is deferred to cosmon-le-repo
  • remote: Remote — server-backed state accessed via network transport. Same gitignore footprint as team; the transport backend is not yet implemented (tracked by cosmon-le-repo)

Options:

• --dry-run — Preview the plan (seal + staging path) without renaming anything
• --no-git — Skip the git-side half of the migration (no git rm --cached, no gitignore/exclude update, no auto-commit). Useful for tests and for galaxies that live outside a git repository
• --no-commit — Apply git-side changes to the index + ignore file but do not create the chore(cosmon): migrate to <residence> residence (git-side) commit. The operator can inspect git status and commit manually

cs migrate verify

Verify the pre-migration BLAKE3 manifest against the current state. Exit codes mirror cs verify: 0 match, 1 divergence, 2 no manifest on record

Usage: cs migrate verify

cs migrate rollback

Roll back the last migration by re-materializing state.prev/

Usage: cs migrate rollback [OPTIONS]

Options:

• --dry-run — Preview which rename would run without touching disk

cs migrate genre

Apply a residence to every tracked path classified under a single genre (ADR-057 artifact-map). Composes artifact-map + git-side migration

Usage: cs migrate genre [OPTIONS] --to <RESIDENCE> <NAME>

Arguments:

• <NAME> — Genre name (must match a [<name>] table in .cosmon/artifact-map.toml)

Options:

• --to <RESIDENCE> — Target residence

  Possible values:

  • solo: Solo — local, single operator. Writes the whole .cosmon/ directory to .git/info/exclude (per-clone notebook, never pushed) and sweeps any legacy .cosmon/ / .worktrees/ lines from the tracked .gitignore (ADR-055 §3.1)
  • team: Team — local, shared across operators via git. Appends .cosmon/state/ to the tracked .gitignore (shared bulletin board) and untracks any previously committed state files. Structural files (config.toml, formulas/*.toml, surfaces.toml) stay trackable on main. Orphan-branch-based state sharing (cosmon/state) is the cosmon-le-repo backend target
  • encrypted: Encrypted — local, encrypted at rest. Same gitignore footprint as team today; the age-wrap backend (requires age on PATH and a --recipient key) is deferred to cosmon-le-repo
  • remote: Remote — server-backed state accessed via network transport. Same gitignore footprint as team; the transport backend is not yet implemented (tracked by cosmon-le-repo)

• --scrub-history — After the residence transition, invoke cs git scrub-history --path <paths> (when available) to rewrite prior commits that touched the matched paths.

  Soft dependency on cs git scrub-history. When the subcommand is not yet implemented, this flag degrades to a one-line warning and the migration still succeeds on the current tree.

• --recipient <AGE_RECIPIENT> — age recipient to wrap the narration for, when --to encrypted is set. Required for the encrypted path

• --dry-run — Preview the plan without writing to disk or touching git

• -y, --yes — Skip the interactive confirmation prompt

cs deps

Deps — show blocking dependencies for a molecule (upstream/downstream)

Usage: cs deps [OPTIONS] <MOLECULE>

EXAMPLES: cs deps # upstream + downstream blockers cs deps --upstream # only predecessors cs deps --json # for scripting

Reads the typed-link DAG (Blocks / BlockedBy).

Arguments:

• <MOLECULE> — Molecule ID (exact or prefix) whose dependencies should be shown

Options:

• --transitive — Walk the full transitive closure instead of only direct edges

cs mission

Mission — read-only DAG view joining ledger edges to completion merge commits

Usage: cs mission <COMMAND>

Subcommands:

• graph — Render the mission DAG rooted at a molecule, joining ledger edges to their completion merge commits

cs mission graph

Render the mission DAG rooted at a molecule, joining ledger edges to their completion merge commits

Usage: cs mission graph <ROOT>

Arguments:

• <ROOT> — Mission root molecule ID (exact or unambiguous prefix)

cs diverge

Diverge — structural agreement check between two sessions on a molecule (turing §5)

Usage: cs diverge [OPTIONS] <A> <B>

EXAMPLES: cs diverge <mol_id> # structural agreement check between two sessions

A structural-agreement primitive: two independent sessions on the same molecule are compared for divergence on the artifacts they produced. Used by livelock detection and consensus checks.

SEE ALSO: cs observe, cs deps.

Arguments:

• <A> — First session — a session id or a path to a galaxy root
• <B> — Second session — a session id or a path to a galaxy root

Options:

• -m, --molecule <MOLECULE> — Molecule id (or prefix) whose views to compare. If omitted, only the git merge-base clause is evaluated and all molecule clauses are marked inconclusive

cs galaxies

Galaxies — inspect the four-family taxonomy

Usage: cs galaxies <COMMAND>

IMAGE: The fleet of repositories is not a flat list — it is four families, classified by the direction the bits flow across the galaxy's boundary:

infra        bits flow inward    the galaxy enables its sisters
project      bits flow through   artefacts + illuminated principles
social-hub   bits flow laterally human-to-human coordination
editorial    bits flow outward   one-way publication to strangers
nascent      not yet classified  awaiting W=28d observable tests

EXAMPLES: cs galaxies list # grouped view, one section per family cs galaxies list --json # flat array + by_kind totals

SEE ALSO: cs status --json (embeds the same galaxies block).

Subcommands:

• list — List every galaxy grouped by its galaxy_kind family
• registry — Inspect the stateless galaxy-name registry (~/.config/cosmon/galaxies.toml) used by cs ask

cs galaxies list

List every galaxy grouped by its galaxy_kind family

Usage: cs galaxies list

cs galaxies registry

Inspect the stateless galaxy-name registry (~/.config/cosmon/galaxies.toml) used by cs ask

Usage: cs galaxies registry <COMMAND>

Subcommands:

• list — List every galaxy declared in the registry TOML
• resolve — Resolve a single galaxy by name. Exits with status 1 if the name is not registered, so scripts can use it as a gate

cs galaxies registry list

List every galaxy declared in the registry TOML.

With --json, emits NDJSON (one entry per line) — the shape cs ask and other pilot agents can pipe into jq without extra envelope parsing.

Usage: cs galaxies registry list

cs galaxies registry resolve

Resolve a single galaxy by name. Exits with status 1 if the name is not registered, so scripts can use it as a gate

Usage: cs galaxies registry resolve <NAME>

Arguments:

• <NAME> — Galaxy name to look up (exact match, case-sensitive)

cs topology

Topology — structural maps of the workspace (wraps the topon CLI)

Usage: cs topology <COMMAND>

EXAMPLES: cs topology map # PageRank-ranked module graph cs topology outline crates/cosmon-core/src/lib.rs cs topology symbols MoleculeId

Thin wrapper over the topon CLI. Structural view, not runtime state.

Subcommands:

• map — PageRank-ranked structural map of a Rust project
• outline — Symbol outline of a single Rust file
• symbols — Search symbols by name across a Rust project

cs topology map

PageRank-ranked structural map of a Rust project

Usage: cs topology map [OPTIONS] [PATH]

Arguments:

• <PATH> — Path to the project root (defaults to current directory)

  Default value: .

Options:

• --max-symbols <MAX_SYMBOLS> — Maximum symbols per module (0 = unlimited)

  Default value: 0

cs topology outline

Symbol outline of a single Rust file

Usage: cs topology outline <FILE>

Arguments:

• <FILE> — Path to the .rs file

cs topology symbols

Search symbols by name across a Rust project

Usage: cs topology symbols <PATH> <QUERY>

Arguments:

• <PATH> — Path to the project root
• <QUERY> — Search query (case-insensitive substring match)