{
  "markdown": "# Context Autopilot\n\n**Automated context collection for coding agents.** Mines your real agent sessions — every instruction you repeated, every correction you made, every tool call you rejected — and distills them into `CLAUDE.md` / `AGENTS.md` rules you approve.\n\nPart of [The Context Layer](https://thecontextlayer.ai).\n\nRun in your terminal (it's a plain CLI — don't paste this into a chat):\n\n```\n$ npx context-autopilot scan\n\nScanned 3 session(s) for ~/projects/my-app\nFound 26 signal(s):\n\n  [CORRECTION] ×2 across 2 session(s)  (score 9)\n      \"There are still so many buttons that dont work, like the publish…\"\n  [REPEATED] ×4 across 3 session(s)  (score 10)\n      \"Do not reference the legacy directory. Only work within…\"\n\n$ npx context-autopilot distill\n\n[1/8] Perform click-and-type tests before reporting UI work complete  (confidence: high)\n    + Before declaring any screen done, click every button and verify it works.\n    evidence:\n      · 2026-06-27 — \"There are still so many buttons that dont work…\"\n\n$ npx context-autopilot apply\n```\n\n## Why\n\nEvery session starts blank, so you re-teach your agent the same conventions — and when you forget, it repeats the same mistakes. Hand-writing context files works but nobody keeps them current. And naive auto-generation is worse: [research on LLM-generated context files](https://todatabeyond.substack.com/p/do-agentsmdclaudemd-files-help-coding) found they *reduce* task success and raise cost, because repo scans produce generic filler.\n\nContext Autopilot takes a third path: **evidence**. Your session history is a literal record of what the agent got wrong and what you said to fix it. Autopilot mines that record and only proposes rules your own words support — each one shipped with the quotes that justify it.\n\n## How it works\n\n1. **Observe** — `ctxlayer scan` parses your local Claude Code transcripts (`~/.claude/projects`) and Cursor sessions and extracts three signal types: instructions repeated across sessions, corrections after the agent went wrong, and rejected tool calls. Runs 100% locally.\n2. **Distill** — `ctxlayer distill` sends the signals (not your history) through Claude — via your existing `claude` CLI, no API key needed — and gets back imperative, project-specific rules with evidence and confidence ratings.\n3. **Approve** — `ctxlayer apply` walks you through each proposal. Accepted rules land in a managed block:\n\n```markdown\n<!-- ctxlayer:begin -->\n## Learned conventions (Context Autopilot)\n\n- **Staff login cannot access admin view** — When authenticated as staff, the admin role toggle must be hidden or disabled.\n<!-- ctxlayer:end -->\n```\n\nHand-written content is never touched; re-runs update the block idempotently. Rules are written to both `CLAUDE.md` and `AGENTS.md`, so Claude Code, Cursor, Copilot, Codex, and every AGENTS.md-aware agent benefits.\n\n## Install\n\n```bash\nnpm install -g context-autopilot   # or use npx, no install\n```\n\n### Commands\n\n| Command | What it does |\n|---------|--------------|\n| `ctxlayer projects` | List projects with observable session history (Claude Code + Cursor) |\n| `ctxlayer scan` | Mine signals from this project's sessions |\n| `ctxlayer distill` | Distill signals into proposals (`.ctxlayer/proposals.json`) |\n| `ctxlayer promote` | Scan every project's saved memory (auto-memory + CLAUDE.md) for rules that belong in your global `~/.claude/CLAUDE.md`; `--dry-run` lists candidates without calling a model |\n| `ctxlayer apply` | Review proposals interactively; write accepted ones |\n| `ctxlayer check` | Fast, model-free: how many new signals since the last distill? `--hook` prints a nudge only past `--threshold` (default 3), else stays silent |\n| `ctxlayer stale` | Find context-file references the repo has outgrown — missing files, removed npm scripts. Exits 1 on findings, so it drops straight into CI |\n| `ctxlayer export` | Export distilled entries as Agent Operating Procedure JSON |\n\n### Global mode\n\n```bash\nctxlayer distill --global\n```\n\nProject context files hold repo conventions — but some feedback is about *you*: \"explain things in plain English\", \"don't build while I'm brainstorming\", \"run independent work in parallel\". Global mode mines **all** your projects across **all** your tools for exactly that, and maintains a managed block in your personal `~/.claude/CLAUDE.md`, so every future session in every project starts already knowing how you like to work. Rules that mention a specific project are excluded by design — those belong in the project's own context file.\n\n### Promote saved memory to global\n\n```bash\nctxlayer promote\n```\n\nWhere global mode mines your *session transcripts*, `promote` mines the memory your agents have **already written down**: each project's auto-memory files (`~/.claude/projects/<name>/memory/`) and each repo's `CLAUDE.md`/`AGENTS.md`. Rules about how you work — or rules duplicated in two or more projects — are proposed for your global `~/.claude/CLAUDE.md`, generalized and with the source files as evidence. Additive only: project files are read, never edited. Anything already covered globally is filtered before the model is even called.\n\nOptions: `--project <path>`, `--global`, `--source claude-code|cursor|all`, `--model <model>`, `--min-score <n>`, `--yes`, `--json`.\n\nCursor session mining reads Cursor's local SQLite storage via Node's built-in `node:sqlite` (Node 22+; on older Node the Cursor source is skipped gracefully).\n\n### Claude Code plugin\n\n```\n/plugin marketplace add chiragbachani/context-autopilot\n/plugin install context-autopilot@the-context-layer\n```\n\nThen ask Claude to \"update project context from my session history\" — or don't ask at all: the plugin ships a **SessionStart hook** that runs `ctxlayer check` (fast, no model call) when a session begins. If enough new signals have accumulated since the last distillation, Claude gets a nudge to offer distillation at a natural pause. No new signals → complete silence.\n\n### MCP server\n\n```json\n{\n  \"mcpServers\": {\n    \"context-autopilot\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"-p\", \"context-autopilot\", \"ctxlayer-mcp\"]\n    }\n  }\n}\n```\n\nExposes `list_observable_projects`, `scan_context_signals`, `distill_context_proposals`, `distill_global_context`, `promote_to_global`, `apply_context_proposals`, and `find_stale_context`.\n\nThe approval loop closes entirely inside chat: distill tools return each proposal with its evidence and instruct the agent to ask you which to accept; `apply_context_proposals` then writes **exactly** the titles you approved, remembers the ones you rejected (never re-proposed), and leaves the rest pending. No tool ever touches a context file without your explicit decision.\n\n## FAQ\n\n**How is this different from Claude Code's `/insights`?**\n`/insights` is the same core observation — instructions you repeat belong in CLAUDE.md — shipped as a personal usage *report*: an HTML page with suggestions you copy-paste by hand, Claude Code only. Context Autopilot is the pipeline version: it also mines **Cursor** history, attaches your **verbatim quotes as evidence** to every rule, runs an explicit **approve/reject** flow, writes accepted rules into **managed blocks** in both CLAUDE.md *and* AGENTS.md (so Codex/Copilot/Cursor benefit), maintains a **global cross-project rules file**, and adds a **CI staleness check**. Fully open source and local.\n\n**How is this different from Claude Code's auto-memory?**\nAuto-memory captures what the model notices *live, in the moment*, in one harness. Autopilot is retroactive and systematic: it mines months of existing history across tools, and finds cross-session patterns (you said it 6× in 4 sessions) that no single live session can see.\n\n## Troubleshooting\n\n- **\"Skill not found\" / agent can't see the tools** — MCP servers load at session start. After installing, start a **new** session (resumed/old sessions won't have the tools), and say \"MCP tools\" rather than a slash command: *\"Using the context-autopilot MCP tools, distill this project's context proposals.\"*\n- Everything else (evidence presentation, approval flow, error hints) is built into the server itself — the tool results tell the agent exactly what to show and when to ask you.\n\n## Privacy\n\nEverything runs on your machine. Transcripts are parsed locally; only the extracted signals (short quotes of your own instructions) are sent to the model you already use for coding. Nothing is uploaded anywhere else, ever.\n\n## Roadmap\n\nCoding agents are chapter one. The engine is source-agnostic — it distills *observations of work* into Agent Operating Procedures (AOPs):\n\n- **Now:** Claude Code + Cursor sessions → CLAUDE.md / AGENTS.md; global cross-project rules (`--global`); staleness detection (`ctxlayer stale`)\n- **Next:** team-shared context; a GitHub Action for context linting in CI\n- **Later:** browser-workflow observation → AOPs for web tasks; ambient capture — until agents absorb the work you repeat, without you ever \"building an agent\"\n\n## License\n\nMIT © [The Context Layer](https://thecontextlayer.ai)\n",
  "bytes": 9042,
  "sha": "615e77c90d33af446bddc019e4b02f5f6f7d8f4f046f78dddd1bd87d111cc0b6",
  "repo_slug": "chiragbachani/context-autopilot",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_chiragbachani_context_autopilo_d02a1da8/readme"
}