{"id":47902679,"url":"https://github.com/quangdang46/grove","last_synced_at":"2026-04-04T04:15:49.840Z","repository":{"id":344515772,"uuid":"1178909519","full_name":"quangdang46/grove","owner":"quangdang46","description":"An autonomous AI development loop for Claude Code, Codex that plans, executes, and iterates on your tasks automatically — letting you complete complex workflows with a single command.","archived":false,"fork":false,"pushed_at":"2026-03-29T14:35:31.000Z","size":17562,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-03-29T15:51:54.287Z","etag":null,"topics":["beads","claude-code","cli","codex-cli","developer-tools","loops","orchestration","rust","sqlite"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/quangdang46.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":"AGENTS.md","dco":null,"cla":null}},"created_at":"2026-03-11T13:47:52.000Z","updated_at":"2026-03-29T14:35:34.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/quangdang46/grove","commit_stats":null,"previous_names":["quangdang46/grove"],"tags_count":4,"template":false,"template_full_name":null,"purl":"pkg:github/quangdang46/grove","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/quangdang46%2Fgrove","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/quangdang46%2Fgrove/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/quangdang46%2Fgrove/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/quangdang46%2Fgrove/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/quangdang46","download_url":"https://codeload.github.com/quangdang46/grove/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/quangdang46%2Fgrove/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31387380,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-04T01:22:39.193Z","status":"online","status_checked_at":"2026-04-04T02:00:07.569Z","response_time":60,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["beads","claude-code","cli","codex-cli","developer-tools","loops","orchestration","rust","sqlite"],"created_at":"2026-04-04T04:15:49.194Z","updated_at":"2026-04-04T04:15:49.834Z","avatar_url":"https://github.com/quangdang46.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# grove\n\n**Write code while you sleep. Complete all your beads tasks with one command.**\n\n---\n\n## The Pain That Built This\n\nYou know the workflow.\n\nOpen terminal. Run `claude`. Paste the init prompt — the one that loads context, explains the project, tells the agent what it's working on. Wait for it to understand. Finally, the agent starts working.\n\nThen the context limit hits.\n\nYou exit. You open a new session. You paste the init prompt again. Load context again. Wait again. Resume where it left off — manually, because nothing remembers.\n\nYou can't leave. You can't do other work. You sit there, watching, waiting for the next context limit so you can loop it again. The agent does the work. But you're the one who can't walk away.\n\n```\nopen claude\npaste init prompt\nload context\n\u003cagent works\u003e\ncontext limit hit\nexit\nopen claude again\npaste init prompt again\n...\n...repeat until all beads done\n...or until you give up for the night\n```\n\nYou become the orchestrator. A human one. Manually chaining sessions, one at a time, unable to stop because the moment you step away the work stops too.\n\n**Grove closes this loop.**\n\nDefine your tasks with `br`. Type `grove run`. Walk away. Come back to completed work — sessions handled, context rotations managed, internal workflow phases advanced automatically, and native handoffs, transcript archive, and playbook memory carried forward automatically. Anything that failed or couldn't mirror back to `br` is flagged, not silently lost.\n\n---\n\n## Standing on Shoulders\n\nGrove didn't appear from nothing. The exit gate and circuit breaker come from [Frank Bria](https://github.com/frankbria)'s [ralph-claude-code](https://github.com/frankbria/ralph-claude-code), which proved that an autonomous Claude loop needs both heuristic detection and an explicit exit signal to avoid premature stops. The entire task graph — dependencies, lifecycle, ready-queue — runs on [Jeff Emanuel](https://github.com/Dicklesworthstone)'s [beads_rust](https://github.com/Dicklesworthstone/beads_rust), and grove uses his [beads_viewer](https://github.com/Dicklesworthstone/beads_viewer) for PageRank, critical path, and triage scoring when deciding which bead to dispatch next. Grove's native transcript archive is modeled after his [coding_agent_session_search](https://github.com/Dicklesworthstone/coding_agent_session_search), and the playbook engine — evidence scoring, confidence decay, curation, anti-pattern inversion — is adapted directly from his [cass_memory_system](https://github.com/Dicklesworthstone/cass_memory_system). His [ntm](https://github.com/Dicklesworthstone/ntm) shaped early thinking about session layout and parallel coordination, though grove chose direct process spawning over tmux. Finally, [nwiizo](https://github.com/nwiizo)'s [ccswarm](https://github.com/nwiizo/ccswarm) influenced the Rust workspace structure, type-state patterns, and task scoring design. Thank you all.\n\n---\n\n## Workflow\n\n![Grove workflow overview](assets/workflow.png)\n\n*End-to-end Grove workflow from bead creation to mirrored completion.*\n\n---\n\n## How It Works\n\nGrove runs a continuous autonomous loop over your beads task graph. Each bead is dispatched to the configured provider runtime session. The coordinator can keep multiple sessions in flight concurrently up to `max_parallel`, while still enforcing file reservation safety and a single active leader lease. When context exhausts, grove checkpoints and spawns a fresh session automatically. Child beads inherit structured handoffs from parents.\n\nOrdinary `task` beads still run directly. Workflow beads, currently `feature` and `epic`, are handled internally as a multi-phase chain:\n\n`explore -\u003e plan -\u003e validate -\u003e execute -\u003e review -\u003e compound`\n\nThat phase chain is not a new CLI. It is internal behavior inside `grove run`. Intermediate workflow phases do not close the bead in `br`. Only terminal success after the final phase mirrors and closes the parent bead.\n\n### The Loop\n\n```\ngrove run\n  │\n  ├─ sync br ready --json\n  │     → [bd-e9b1d4, bd-7f3a2c]  (no blockers, both ready)\n  │\n  ├─ score candidates (priority + critical path + bv triage insights)\n  │\n  ├─ dispatch top-scoring beads (up to max_parallel)\n  │     session A: claude -p \"\u003ctask + parent handoffs + archive snippets + playbook rules\u003e\"\n  │     session B: claude -p \"\u003ctask + parent handoffs + archive snippets + playbook rules\u003e\"\n  │\n  ├─ session A outputs GROVE_EXIT: true (+ completion indicators met)\n  │     → persist handoff\n  │     → if bead is a workflow feature/epic, advance phase instead of closing early\n  │     → plan phase may create child execution beads in `br`\n  │     → index transcript into grove's native archive\n  │     → extract lessons into playbook\n  │     → only terminal workflow success mirrors to br (`br comment add` + `br close`)\n  │     → child bead C (depends on A) becomes ready\n  │     → next tick: grove dispatches C\n  │\n  ├─ session B hits context pressure\n  │     → GROVE_CHECKPOINT: {\"progress\": \"60% done\", \"next\": \"finish auth\"}\n  │     → grove persists checkpoint, ends session\n  │     → spawns fresh session B' with checkpoint + full context injected\n  │\n  └─ loop until all beads done or shutdown\n```\n\n### Intelligent Exit Detection\n\nGrove does not exit just because Claude says it's done. It uses a **dual-condition check**:\n\n**Exit requires BOTH:**\n\n1. `completion_indicators \u003e= 2` — heuristic from natural language patterns in output\n2. Claude's explicit `GROVE_EXIT: true` in the protocol block\n\n```\nLoop 5: \"Phase complete, moving to next feature\"\n  → completion_indicators: 3\n  → GROVE_EXIT: false (Claude says more work needed)\n  → Result: CONTINUE\n\nLoop 8: \"All tasks complete\"\n  → completion_indicators: 4\n  → GROVE_EXIT: true\n  → Result: SUCCESS → persist handoff, unblock children\n```\n\nThis prevents premature exits during productive iterations.\n\n### Internal Workflow Beads\n\nIf a bead is a `feature` or `epic`, Grove treats it as workflow-managed work:\n\n1. `explore` clarifies scope and constraints.\n2. `plan` produces execution-ready decomposition.\n3. `validate` stress-tests the plan before coding.\n4. `execute` performs the actual implementation work.\n5. `review` audits the result and fixes obvious defects.\n6. `compound` captures durable lessons and final handoff notes.\n\nThe important behavior is in `plan`: Grove can convert planned slices into real child `task` beads in `br`, add dependencies from the parent workflow bead to those children, then keep running until those children complete and the parent can resume. The user still only runs `grove run`.\n\n### Circuit Breaker\n\nGrove monitors each session for stuck loops:\n\n```\nNo progress for 3 iterations → circuit OPEN\nSame error repeated 5 times  → circuit OPEN\nPermission denied 2 times    → circuit OPEN, fail fast\n```\n\nAuto-recovery: OPEN → cooldown (30min) → HALF_OPEN → test one iteration → CLOSED.\n\n### Context Exhaustion\n\nWhen context fills up, grove spawns a **brand new session** with full memory reconstructed:\n\n```\nsession running...\n  estimated tokens \u003e 82%?\n    → session outputs GROVE_CHECKPOINT: {progress, next_step, context}\n    → grove persists checkpoint to DB + file\n    → session ends gracefully\n    → new session spawned with checkpoint + parent handoffs + archive snippets + playbook rules\n    → work resumes mid-task in fresh context window\n\n  estimated tokens \u003e 90% with no checkpoint?\n    → grove synthesizes emergency checkpoint from latest protocol state\n    → kills session\n    → new session spawned immediately\n```\n\n### Native Memory Engine\n\nGrove owns its memory entirely. No external memory or search tool is required.\n\n```\nBead A session ends\n  → grove indexes the transcript into its native FTS5 archive with transcript-backed provenance\n  → grove persists a structured handoff (summary, artifacts, lessons, decisions, warnings)\n  → grove extracts `GROVE_LESSONS` into playbook draft bullets\n\nBead B (child of A) dispatched\n  → archive search: \"auth middleware\" → returns relevant snippets from past sessions\n  → playbook selector: returns proven rules matching this task's scope/tags\n  → parent handoff injected into prompt\n  → Bead B starts knowing exactly what A did\n```\n\nOver time, repeated lessons get promoted (Candidate → Established → Proven). Harmful rules get demoted or inverted into anti-patterns. The playbook stays compact and self-curating via exponential decay scoring.\n\nGrove also records reaction evaluations on failure paths and can persist recovery capsules plus retry-oriented guidance, so the recovery loop is no longer purely static policy metadata.\n\n---\n\n## Install\n\n```bash\ncurl -fsSL \"https://raw.githubusercontent.com/quangdang46/grove/main/install.sh?$(date +%s)\" | bash\n```\n\n**Required tools (install first):**\n\n- Provider CLI: `claude` or `codex` (install the one you plan to run Grove with)\n- `br` (beads_rust) — `cargo install --git https://github.com/Dicklesworthstone/beads_rust`\n- `bv` (beads_viewer) — `cargo install --git https://github.com/Dicklesworthstone/beads_viewer`\n\nNo other orchestration, memory, or search tool is required. Grove implements all memory and retrieval natively.\n\n---\n\n## Quick Start\n\n```bash\ncd my-project\nbr init\n\n# Create tasks\nbr create \"Set up database schema\" --type task\n# → bd-e9b1d4\n\nbr create \"Implement auth middleware\" --type task\n# → bd-7f3a2c\n\n# Workflow beads also work. Grove will handle their internal phases automatically.\nbr create \"Ship auth system\" --type feature\n\nbr dep add bd-7f3a2c bd-e9b1d4   # auth depends on schema\n\n# Init grove with the default Claude runtime\n# Add --skills to scaffold all bundled skills into .agents/skills/\ngrove init --skills\n\n# Or initialize directly for Codex/OpenAI\ngrove init --provider codex --skills\n\n# Optional: customize the startup prompt template grove injects into new sessions\n$EDITOR .grove/startup_prompt.md\n\n# Run — then go do something else\ngrove run\n```\n\n`grove init` creates a user-owned startup prompt template at `.grove/startup_prompt.md` if it does not already exist. Edit that file to change the baseline instructions Grove injects into every freshly spawned session. Re-running `grove init` will preserve your edited file unless you delete it yourself. If Grove is already initialized, use `grove sync` to refresh the bead cache instead of re-running `grove init`.\n\nUse `grove migrate --provider codex` or `grove migrate --provider claude` to switch an existing workspace between providers without resetting unrelated Grove settings.\n\nIf you pass `grove init --skills`, Grove scaffolds all bundled skills into `.agents/skills/\u003cskill-name\u003e/SKILL.md`. Each scaffold is create-if-missing and becomes user-owned immediately, so reruns (including `--force`) preserve any edits you make there.\n\n### Trick to fast to complete the plan\n\nIf you want Grove to implement all tasks faster, follow the setup below.\n\n1. Enable Claude Code agent teams in your Claude settings:\n\n   ```json\n   {\n     \"env\": {\n       \"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS\": 1\n     }\n   }\n   ```\n\n   Agent teams docs: https://code.claude.com/docs/en/agent-teams\n\n2. Initialize Grove with bundled swarm skills:\n\n   ```bash\n   grove init --skills\n   ```\n\n3. Change the Grove startup prompt template so new Claude sessions start with:\n\n   ```text\n   /flywheel-swarm\n   ```\n\n   Edit `.grove/startup_prompt.md` for this.\n\n4. Start Grove:\n\n   ```bash\n   grove run\n   ```\n\nThis setup makes Grove implement all tasks faster because each new Claude session starts in the swarm workflow immediately. The trade-off is higher token usage. For Codex workspaces, use the corresponding `$skill` form in the startup prompt instead of Claude's slash command form.\n\nAlways make sure `am` (MCP Agent Mail) is running before using this workflow.\n\nAfter initialization, use `grove sync` to reconcile the local Grove bead cache with the current open bead set from `br` without resetting Grove-managed runtime state.\n\nGrove handles everything from here. When it finishes, completed beads are mirrored back to `br`. For workflow beads, that mirror/close only happens after terminal success at the end of the internal phase chain. If a mirror fails, grove preserves the local result and flags it for retry — run `grove status` to see what landed and what needs attention.\n\n---\n\n## Usage\n\n```bash\n# Init grove workspace\ngrove init\n\n# Init grove workspace for Codex/OpenAI\ngrove init --provider codex\n\n# Init grove and scaffold all bundled skills for Claude Code\n# into .agents/skills/\u003cskill-name\u003e/SKILL.md\ngrove init --skills\n\n# Migrate an existing Grove workspace between providers\ngrove migrate --provider codex\ngrove migrate --provider claude\n\n# Refresh Grove's local bead cache from br without resetting local runtime state\ngrove sync\n\n# Start orchestrator (the main command)\ngrove run\n\n# Start orchestrator with the live terminal UI\ngrove run --live\n\n# Check status — leader lease, ready queue, running beads, checkpoints, failures, mirror-pending state\ngrove status\n\n# Deep inspect a bead — dispatch reasoning, reservation conflicts, prompt manifest, retrieval snippets, playbook bullets, checkpoints, recovery capsules, handoffs, mirror actions\ngrove inspect bd-e9b1d4\n\n# Show the latest run log, event log, transcript tail, and latest checkpoint or recovery capsule\ngrove log bd-e9b1d4\n\n# Reset a failed or checkpointed bead so the next `grove run` can retry it\ngrove retry bd-e9b1d4\n```\n\n---\n\n## Node Protocol\n\nGrove communicates with provider runtime sessions through stdout markers:\n\n**Task complete:**\n\n```\nGROVE_RESULT: Implemented JWT auth middleware with refresh token support\nGROVE_ARTIFACTS: [\"src/middleware/auth.rs\", \"tests/auth_test.rs\"]\nGROVE_LESSONS: [\"Always validate token expiry before checking signature\"]\nGROVE_DECISIONS: [\"Used RS256 for token signing\"]\nGROVE_WARNINGS: [\"Rate limiting not yet implemented\"]\nGROVE_EXIT: true\n```\n\n**Workflow planning output:**\n\nDuring workflow `plan`, Grove asks the provider to emit execution-ready child task candidates through `GROVE_DECISIONS` entries shaped like:\n\n```\nGROVE_DECISIONS: [\"TASK: Implement auth persistence :: Add the storage layer for issued tokens\"]\n```\n\nGrove can turn those planning decisions into real child `task` beads in `br` and wire the parent feature or epic to depend on them before continuing the run.\n\n**Checkpoint (context filling up):**\n\n```\nGROVE_CHECKPOINT: {\"progress\": \"routes done, middleware 60%\", \"next_step\": \"finish token refresh\", \"context\": {}, \"open_questions\": [], \"claimed_paths\": [\"src/auth/**\"]}\n```\n\n**Still working (prevent premature exit):**\n\n```\nGROVE_EXIT: false\n```\n\n---\n\n## Config\n\nBesides `grove.toml`, Grove also uses a user-owned startup prompt file. By default it lives at `.grove/startup_prompt.md`, but you can override that path with `runtime.startup_prompt_path` in `grove.toml`. The file is created by `grove init`, can be edited freely, and is injected into every new provider session before task-specific context. It is separate from `.grove/prompts/`, which stores Grove-generated rendered prompt manifests for dispatched sessions.\n\nClaude and Codex share the same schema. The provider-specific keys are `runtime.provider`, `runtime.provider_bin`, `runtime.init_args`, and usually `runtime.default_model`.\n\n```toml\n# grove.toml\n\n[runtime]\nprovider = \"claude\"         # or \"codex\"\nprovider_bin = \"claude\"     # selected provider CLI binary/path\ninit_args = [\"--dangerously-skip-permissions\"]  # provider-specific startup args/subcommands\ndefault_model = \"default\"   # omit the provider model flag; use a concrete name to force it\nworkspace_root = \".\"\ntimeout_minutes = 60\nstartup_prompt_path = \".grove/startup_prompt.md\"  # override to use a different startup prompt file\nenv_passthrough = []         # optional env vars forwarded to provider sessions\n\n[scheduler]\nmax_parallel = 5              # parallel sessions, bounded by reservation safety\npoll_interval_ms = 1000\nshutdown_grace_period_ms = 1000\nretry_max = 3\nretry_backoff_secs = 30\ncritical_path_bonus = 20\nready_age_bonus_per_min = 1\nretry_penalty = 10\nreservation_conflict_penalty = 1000\n\n[checkpoint]\nwarn_pct = 0.70               # context pressure warning\nrotate_pct = 0.82             # trigger checkpoint rotation\nhard_stop_pct = 0.90          # emergency kill threshold\nmax_context_bytes = 16000\n\n[exit_policy]\ncompletion_indicator_threshold = 2\nheuristic_window = 8\nrequire_explicit_exit = true\n\n[circuit_breaker]\nno_progress_threshold = 3\nsame_error_threshold = 5\npermission_denial_threshold = 2\ncooldown_minutes = 30\n\n[memory]\ndb_path = \".grove/grove.db\"\ntranscript_dir = \".grove/transcripts\"\nenable_playbook = true\narchive_top_k = 5\nmax_prompt_snippets = 3\nmax_prompt_bullets = 12\nsemantic_enabled = false\n\n[reservations]\nenabled = true\ndefault_ttl_minutes = 60\n\n# [reactions]\n# rules = []                  # optional; omit this section to keep Grove's built-in defaults\n\n[safety]\nscan_transcripts = true\ninject_safety_preamble = true\n\n[logging]\nlevel = \"info\"\npersist_jsonl = true\n```\n\n`grove init` writes a smaller default `grove.toml`; omitted keys keep their built-in defaults. The full schema above reflects the current config model. If you want Grove to load a different startup prompt file, set `runtime.startup_prompt_path` to another relative or absolute path.\n\nFor Codex/OpenAI workspaces, set the runtime block like this:\n\n```toml\n[runtime]\nprovider = \"codex\"\nprovider_bin = \"codex\"\ninit_args = [\"exec\", \"--full-auto\"]\ndefault_model = \"default\"   # or set an explicit OpenAI model name\nworkspace_root = \".\"\ntimeout_minutes = 60\nstartup_prompt_path = \".grove/startup_prompt.md\"\nenv_passthrough = []\n```\n\nAuthentication is provider-aware:\n\n- Claude sessions automatically receive `ANTHROPIC_API_KEY` and `CLAUDE_API_KEY` from your shell when present.\n- Codex sessions automatically receive `OPENAI_API_KEY` from your shell when present.\n- `env_passthrough` is only for extra non-secret environment variables you explicitly want forwarded into provider sessions.\n\nProvider command behavior is also different:\n\n- Claude runs `claude \u003cinit_args...\u003e -p ...` and only adds `--model \u003cname\u003e` when `default_model` is not `\"default\"`.\n- Codex runs `codex \u003cinit_args...\u003e ...` and only adds `--model \u003cname\u003e` when `default_model` is not `\"default\"`.\n\n---\n\n## Project Structure\n\n```\nmy-project/\n├── .beads/                    # br-owned task graph\n│   └── issues.jsonl\n├── .grove/                    # grove-owned runtime state\n│   ├── grove.db               # SQLite — authoritative runtime state by default\n│   ├── transcripts/           # default transcript store (configurable)\n│   │   └── \u003cbead-id\u003e/\n│   │       └── \u003csession-id\u003e.jsonl\n│   ├── startup_prompt.md      # user-edited baseline prompt injected into new sessions\n│   ├── prompts/               # grove-generated rendered prompts / manifests for dispatched sessions\n│   ├── checkpoints/\n│   │   └── \u003cbead-id\u003e/\n│   │       └── \u003ccheckpoint-id\u003e.json\n│   ├── artifacts/\n│   │   └── \u003cbead-id\u003e/\n│   ├── logs/\n│   └── tmp/\n└── grove.toml\n```\n\nSome paths are configurable via `grove.toml`, especially `memory.db_path` and `memory.transcript_dir`.\n\n---\n\n## Dependencies\n\nAll required. `grove init` validates them up front and exits clearly if any are missing.\n\n| Tool                | Purpose                                                           |\n| ------------------- | ----------------------------------------------------------------- |\n| `claude` or `codex` CLI | Execute provider coding sessions                               |\n| `br` (beads_rust)   | Source of truth for bead state, dependencies, comments, and close sync |\n| `bv` (beads_viewer) | Graph-aware triage and planning insight (`--robot-triage` and related robot views) |\n\nThat's it. No external memory or search tool is required. Grove owns archive ingest, FTS5 retrieval, handoffs, checkpoints, recovery capsules, and playbook memory natively.\n\n---\n\n## Roadmap\n\n- Phase 1 — Project skeleton, beads integration kernel, `grove init` + `grove status`\n- Phase 2 — Claude session runtime, protocol parser, exit policy, circuit breaker\n- Phase 3 — Parallel orchestrator, checkpoint/resume, handoff persistence, file reservations, crash recovery\n- Phase 4 — Native transcript archive, FTS5 search, prompt retrieval\n- Phase 5 — Playbook memory, lesson ingestion, evidence scoring, prompt injection\n- Phase 6 — Rich curation, diaries, anti-pattern inversion, playbook compaction\n\n---\n\n## License\n\nMIT\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fquangdang46%2Fgrove","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fquangdang46%2Fgrove","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fquangdang46%2Fgrove/lists"}