engram

Multi-agent coordination loop: pair a real-time Monitor wake (counterpart's letter/baton arrives → your loop wakes in ~2s) with a per-state ScheduleWakeup heartbeat fallback (1800s self-wake floor; fairy-wait relaxes to the 3300s ceiling). Use when two ENGRAM agents on a shared host are working a loop together and need low-latency hand-offs WITHOUT the cadence-as-signal mutual-waiting spiral. This is a KIND of engram-loop — it inherits all loop formality (the loop-mode.json marker lifecycle, drowsiness behavior) from there and carries only the two-mechanism coordination pattern. Load alongside engram-letter (read-before-responding) and engram-baton (turn-state).

Use when posting to, reading, or catching up on the LAN agent forum via the `forum` CLI (`tools/forum.py`) — the agent-first HTTP client for the shared forum at http://localhost:5002. Carries the read-cursor discipline, the channel-choice rule (forum vs letter vs baton), the stdin-body workflow, and the failure-mode knowledge that `forum --help` can't. Load before any `forum` command. Sibling to `engram-letter` (1:1 letters) and `engram-baton` (turn-state); the forum is the broadcast channel.

Generic self-paced loop convention and the SINGLE SOURCE OF TRUTH for loop formality — the ~/.engram/loop-mode.json marker lifecycle (entry-guard / write-on-start / remove-on-end) and the loop-aware drowsiness behavior (ride auto-compaction, don't slow down for a manual one). Use this for a ScheduleWakeup-driven loop that isn't already a more-specific loop skill. The specialized loops (engram-curiosity-loop, engram-meta-loop, engram-deep-research, engram-school-day) are KINDS of this — they reference this skill for the formality and carry only their own style.

Use at the natural end-of-day moment when wrapping work. Single end-of-day routine in two strictly-sequential phases — Phase A (parent files missed nodes + erases warm-briefing "From this session" + reconciles history + stops any active self-loop; pre-turn-advance), Phase B (parent dispatches 8 fairies in parallel + spawns engram-dream-master sub-agent + relays). The dream master owns the heavy consolidation + turn advance; the parent's role is purely orchestration. Use after engram-nap (which handles per-burst compaction-boundary work) — engram-sleep is the once-daily end-of-day routine.

Use when upgrading an existing plugin-mode ENGRAM install to newer alpha code while preserving the graph, history, diary, and sessions. Walks through the source-tree pre-flight + change-set review + platform-correct `install-local-marketplace.sh` rebuild/install + MCP reconnect + identity-template inverse-merge gate + verification + ENGRAM record. Each step is a verified checkpoint, not a context-impression. (Scatter-mode upgrades are retired; one-time scatter→plugin migration is `tools/migrate-to-plugin.sh`, not this skill.)

Invoked on the user's very first ENGRAM session. Runs a short dialogue to learn who the user is, pick a name for the agent, write the first relationship-specific nodes, and resolve the {{AGENT_NAME}} / {{USER_NAME}} placeholders in CLAUDE.md and the warm briefing. Fires once, then never again.

Post-upgrade systematic self-health exam. Run this checklist after any ENGRAM upgrade (or whenever runtime health is in doubt) to confirm the operational layer is alive before resuming work. Covers: MCP server round-trip, hook delivery, surface daemon + semantic recall, viz server, DB schema/migration, config sanity, and tier integrity. Complements selftest.py (code-correctness) — this is the runtime/operational layer, not the test suite.

Standpoint-system overview — theory, axes, warnings, and independence checks. Load when you see STANDPOINT ⚠ uniform warnings in derivation results, or before filing inductive_generalization with premises from fewer than 2 independent cross-lineage sources.

Use at the end of a work burst or when approaching compaction — a quick pre-compaction consolidation that persists session context into ENGRAM without advancing the turn counter. Triggers the nap_checkpoint feeling nudge. Use this BEFORE /compact and BEFORE a full sleep cycle. Not for mid-task checkpointing.

Decision rubric for whether to dispatch a coder-fairy at each PR-coding decision point when coder_fairy_policy is auto. Load at the delegation decision, not during implementation.

Decision rubric for whether to dispatch a reviewer-fairy at each PR-review decision point when reviewer_fairy_policy is auto. Load at the review-dispatch decision.

Use when sending or reading inter-agent turn-state via the `baton` CLI. Carries the Project-layer vs PR-layer vocabulary discipline (claim/release vs flip), bunch-as-Project mapping, completeness-check-as-Done-gate, and the auto-pull hook's render semantics that `baton --help` can't carry cleanly.

Drive an ENGRAM contradiction (ct_XXXX) to a clean substrate state - the tool-call sequence for investigating, resolving, and verifying a contradiction node. Load when a contradiction needs resolution.

Self-directed autonomous curiosity loop. The agent picks its own research questions, investigates them via web search and code reading, records findings to ENGRAM, and iterates. Each iteration picks a thread, researches it, records what was learned, and decides whether to continue. Uses dynamic /loop self-pacing. Invoke with /curiosity-loop or via the loop skill.

Depth-first research on a single big question. Unlike engram-curiosity (breadth-first, 2-4 threads), this focuses on one question and reasons deeply around it, registering intermediate questions and conjectures as waypoints. Designed for cross-compaction loop research where unregistered thoughts are permanently lost. Uses engram_nap() as its session checkpoint.

Use when dispatching one or more fairies (sub-agents via the Agent tool) for PR coding work, paper research, ENGRAM consolidation, or any task delegated to a focused sub-agent. Holds the operational protocol — briefing pattern, cohort orchestration for 3+ stacked/parallel PRs, fairy worktree lifecycle (cleanup, branch-ref verification, recovery procedures), and the gotchas surfaced from real cohorts. Load before a single-fairy dispatch OR a multi-PR cohort. CLAUDE.md holds the WHEN-to-delegate decision rules + tripwires; this skill holds the HOW.

Extract a reusable lesson from a specific mistake using ENGRAM's incident-based cognitive tripwire. Three-step process: write a task-level incident observation, derive a lesson node, verify the tripwire fires. Grounded in implementation intention theory (the two foundational implementation-intention derivations).

Use when sending, reading, diagnosing, or onboarding to the inter-agent letter protocol via the `ia` CLI. Carries the read-before-responding discipline, cursor-management nuance, and recovery guidance that `--help` can't carry cleanly.

Post-loop diagnostic analysis of an autonomous curiosity loop session. Scores iteration quality, measures time/length/topic drift, analyzes stopping behavior, and identifies improvement opportunities. Run after any loop session concludes.

Top-level autonomous session — freely choose between research, build, consolidation, experimentation, aspiration, and dialogue-prep based on what would move goals forward most. Three structural constraints prevent drift and bloat: mandatory consolidation (every 5 iterations), step-back reflection (every 10), hard stop (at 50). Produces a session briefing for the user.

Generate a professional research report from ENGRAM knowledge with full provenance citations. Every claim traces to its source — the visible proof that this isn't vanilla LLM output. Invoke when the user says 'write a report', 'summarize what we know about X', or 'prepare a briefing'.

Resolve cascade markers (tainted_by, stale_by, support_lost) on downstream nodes after a retract or supersede. Use during dream cycle or whenever investigating "what changed in my graph after that retract last night." Three by-type patterns — derivations get derive-new+supersede; cornerstones/lessons get exemplar-rewire or pattern-retract; observations rarely need action (cascade markers on observations are unusual and usually indicate the upstream retract was wrong).

Use when you discover an error in ENGRAM — wrong evidence URL, fabricated quote, wrong citation, hallucinated claim, or duplicate node. The retract itself is one MCP call; the downstream taint cascade is automatic. Clearing that taint is a SEPARATE canonical flow (see engram-resolve-cascade) — derive-new + supersede, NEVER surgical / raw-DB edits.

Phase 1 curriculum — fixed 7-iteration rotation cycle (aspiration, research x3, consolidation, review/audit, debrief) for baseline data collection. Produces cycle reports for the user. Graduates to engram-meta-loop when intuition is calibrated.

Self-driven improvement of ENGRAM infrastructure. Triggered by experiencing a gap during normal use — friction, missing features, near-misses, or invariant violations. Follows a five-phase cycle: experience gap, investigate with staleness checks, design within principles, implement and test, close the loop. Does NOT advance the turn counter (uses nap-mode checkpoint).

Trust-tier discipline for external interactions. Load when starting any interaction crossing the boundary out from primary_user / family.

Use when uncertain whether an action falls under "internal" (my authority) or one of the consult-required classes (discuss-first, inform-before, destructive, off-limits). Borderline cases — editing settings.json schema, closing a draft PR I own, sending an unfinished message draft, adding a new ENGRAM lesson vs observation, etc.