Doctrine

Command Center's agents are governed by written doctrine: plain Markdown files, shipped with your install, that every agent reads and follows. This page maps that corpus — what each piece governs and where it lives on your disk. It deliberately does not reproduce any of it: the full text ships inside the product. When you want the actual rules, open the files themselves — they are yours to read, and yours to edit.

Why written doctrine works

Two properties turn these files into an operating system for agents rather than documentation:

• They carry instruction priority. The operating contract is injected into every agent session as project instructions that take precedence over the model's default behavior. A convention written here is policy, not a suggestion.
• They are read fresh, every time. Agent sessions read the doctrine at spawn; protocols are read on demand during a run. Edit a file and the very next session behaves differently — no rebuild, no restart, no deployment.

The consequence is the platform's core leverage: a freshly started agent process arrives knowing nothing about your operation and becomes competent purely by reading — and you change how the whole fleet behaves by editing text. Because it is all plain files, every change is diffable and version-controllable.

The operating contract — CLAUDE.md

CLAUDE.md at your install root is the entry point of the whole corpus. It governs what every agent knows before it does anything: the map of the memory layers and which holds what, the session-start ritual (check memory, skim the knowledge graph, read the standing directives), the agent roster, the index of protocols, the tool and daemon reference, and the document lifecycle — including the naming convention every agent-written report follows and the lifecycle flags that move files through your workspace.

It routes rather than rules: the deep contracts live in the protocol files it points to, which keeps the always-loaded contract lean. As you shape the platform to your operation, this is the file you extend first.

The protocol set — .claude/protocols/

Each protocol governs one concern, declares who reads it, and is loaded by agents when the concern is at hand. The shipped set, by name and function:

One member of the set is a suite rather than a file: copywriting/ — the content-authoring doctrine for reader-facing writing. A master file plus core rules that always apply, one module per genre (news, report, marketing, explainer, video and audio scripts, email, social, microcopy), stackable profiles for audience, voice, and language, named loadouts for common jobs, and annotated exemplars. Agents load the relevant slice when they write for human readers.

The pattern is extensible by construction: adding your own rule means writing a new protocol file and adding one line to the contract's index. It binds your agents from the next session on.

The grand blackboard — documents/grand-blackboard/

Three files carry your operation's standing strategic state, read by agents at session start:

These ship as scaffolds with worked structure; the content becomes yours. They are the reason a brand-new session starts aligned with your priorities instead of asking. How missions themselves run is covered in Missions & the fleet.

Session digests — documents/general_reports/logs/session_logs/

The continuity record. At the end of a significant working session, a digest is written — what was done, what was decided, what is owed — with later same-day sessions adding parts and older months moving to an archive subfolder. Digests are what let any future session (or you, after a week away) reconstruct context without replaying history. The protocol above defines when one is due and what it must contain.

Where everything lives

This manual describes the corpus; it does not duplicate it. The files on your disk are the single source of truth — read them there, and edit them there.

Where to go next

• Agents — the roster the doctrine governs
• Memory — the layer system the memory protocol routes
• The operator model — how you direct a system that runs on written rules