wyrm

Use when another buddy-compatible MCP server (or the operator) asks Wyrm for a brief, data-grounded status reply - the Buddy Protocol v1.0 well-known entry point. Companion params switch to the full companion reply; bare calls stay protocol-pure. Cycle-protected.

Use to pursue a goal autonomously - the OODA loop: observe Wyrm context, orient, decide one whitelisted tool call, act, loop. Pass goal_id for an existing goal, or query+title to create and pursue ad-hoc.

Use for the tamper-evident audit chain - action=log (append a tamper-evident, hash-chained record of an admin action), export (the audit history as an offline-verifiable bundle for a compliance review), verify (prove the audit trail hasn't been tampered with).

Use to call a tool on an outbound MCP server registered via wyrm_mcp - lazily spawned over stdio, result returned and logged to external_call_log.

Use to learn what your memory system can actually do - feature inventory, why each matters, runtime state, and which tool to reach for. Call at session start instead of re-discovering the surface.

Use to save anything worth keeping - the single write funnel. Auto-classifies notes, decisions, and lessons into quest, ground truth, or memory; risky writes queue for wyrm_review. mode=direct (store a proven pattern or lesson learned so future agents reuse it), extract (pull memories from a conversation transcript or freeform text), trace (harvest a session JSONL / tool-call log into run-tagged review candidates), session (close out a work session into reusable knowledge), artifacts (harvest a repo's READMEs and recent commits into durable facts), import source=git|pr|rules, spec (turn a tasks.md into tracked work items), checklist, feedback (artifactId + success: mark what you recalled as useful, or not). Keywords: remember this, jot down, write down, future reference.

Use to build a compact context brief for the current task under a token budget - relevant patterns, lessons, and truths in one formatted block; max_tokens elides low-score items to recallable stubs.

Use to link a choice or decision to the assumption or evidence it was based on - records a causal edge (truth/quest/artifact/session) so stale foundations invalidate downstream.

Use to trace decision causality - action=upstream (why did we pick this? walk me through the reasoning chain back to its sources), downstream (if that assumption turns out to be wrong, what else breaks - the blast radius), invalidate (a foundational fact was wrong: flag everything we built on top of it, cascading).

Use for the project's design system - store and read the values the brand uses: color, type, spacing, motion, shadow, radius, breakpoint. action=set (upsert a primary color or spacing value), get (what values does this design system use?), delete.

Use for the knowledge graph - action=add (a person, vendor, service, or concept), link (record that Alice maintains the deploy pipeline: who maintains, uses, or depends on what), search, merge (destructive), path (how two entities or services are related to each other), graph (show everything connected to an entity, N hops).

Use before proposing or executing any fix, command, or approach - did this fail before? Is it a known landmine? Counter-pattern memory: returns unresolved matching failures (empty = safe to proceed); show the mistakes already made on a project with `wyrm failure list` (CLI). Subagents: check before retrying anything flagged.

Use when an approach failed or something broke - log the dead end so nobody tries it again. Identical (scope, target, description) coalesces with occurrences++; when the root cause is fixed, stop flagging it with `wyrm failure resolve <id>` (CLI). Run-scoped failures quarantine until confirmed.

Use for persistent goals the wyrm-loop daemon pursues autonomously - action=set (define with success criteria), list, complete, pause, resume, abandon, iterations (the OODA pursuit history).

Use for periodic upkeep of the memory store - archive old sessions, vacuum, prune stale events, sweep run quarantine. Admin-gated, destructive; fleets run it between waves.

Use to manage outbound MCP servers Wyrm can call - action=register (command, args, env), list, tools (one-shot tools/list), disable. Call a registered server's tools via wyrm_call_external.

Use for multi-agent presence - who else is working on this right now? action=list, announce (I'm online and working on X; a TTL heartbeat orchestrators and other agents see), release (clean exit: clears presence and drops any quest claims held).

Use for the project registry and cross-project landscape - action=list, context (one project's memory overview), scan (discover and register git repos under a directory), sync (DB rows to per-project .wyrm folders).

Use for project tasks and todos - action=add (add a todo or work item), complete (mark a task as done), claim (lock a quest so other agents don't duplicate the work; TTL lease stamped with agent_id/run_id), release, list (what's still open on my plate across all projects). The fleet coordination primitive.

Use before starting any non-trivial task - what do we know about this? Pull up relevant lessons learned, proven patterns, anti-patterns, and reasoning traces from past work. Hybrid lexical+semantic retrieval, fully local, no LLM. Rate a result with wyrm_capture mode=feedback.

Use for design references and visual inspiration - action=add (clip a website, image, palette, or snippet to keep for later projects), search (find that inspiration link I saved a while back), list.

Use to sync memory between machines and watch the live event mesh - action=start|stop|status|tick (daemon + peers; tokens via tokenEnv), conflicts (did the last sync leave conflicts to resolve?), resolve, publish, since, subscribe (watch a project's live activity feed for changes from other agents), replicate (one-shot: sync my memory over to another machine or peer), unshare (kind + id: make a record private again so it does not leave this machine). Back up the memory database off this machine, encrypted: wyrm cloud backup (CLI).

Use to process the review queue - approve or reject the pending memory candidates waiting from extraction, harvest, imports, capture conflicts, or session distillation. Approve activates the artifact for recall; reject permanently deletes it (unrecoverable).

Use to manage a fleet run lifecycle from the orchestrator: action=start mints a ULID run_id and registers the orchestrator, join registers each subagent (agent_id, role), status reports agents, run-quarantined failure counts, and quest claims, debrief fans each agent's learnings through the LOCAL extractor (never a cloud LLM) into a run-scoped review queue for wyrm_review, and end writes the run summary, promotes or expires quarantined failures, and releases claims.

Use to find anything by keyword or meaning across all projects - find past sessions that mention a topic, look up everything we have about a service, or ask have I solved this problem before in any other project (cross-project constellation). FTS/vector/hybrid; where a function or symbol is defined across repos: type=symbols.

Use to track working sessions - action=start (start tracking a new working session on a repo), update (log what you just finished: completed work, issues, commits), rehydrate (the full briefing from a past session so a fresh agent can take over).

Use first at session start - load everything you need to know before starting work, and catch me up on where we left off last time: ground truths, memory brief, reasoning scaffold, and active quests in one call. First call every agent makes in a run.

Use to share a finding with the rest of the team - marks a row (session/quest/truth/artifact/edge) is_shared for the next sync push; revoke with wyrm_replication action=unshare.

Use for reusable playbooks (skills) - do we already have a playbook for this? action=list (the playbooks and capabilities registered on this machine), search, get, register, create (package what you just learned into a reusable skill), activate, deactivate, graph (governance tree), stats, delete.

Use for a health snapshot of the memory database - row counts, vector index coverage, usage.

Use to get or nudge the project's working thread: a compact, always-current snapshot (objective, in-progress work, last decisions, open loops, next step, what's in play) assembled live from Wyrm's signals and persisted to the threads table. action=get assembles, persists, and renders the current thread. action=nudge additionally merges an advisory note first: a plain note seeds in-progress (only if no session signal already covers it), while a note prefixed 'loop:' appends one open loop. The signal-derived open loops, decisions, and in-play are never replaced by a nudge.

Use to read the established facts and ground rules for a codebase - validated truths the AI should treat as baseline, optionally filtered by category.

Use to lock in a confirmed fact or constraint as project ground truth - architecture, conventions, key decisions. Injected first into every brief; re-setting the same category+key supersedes (history kept).