Generated banner for agentic-stack
Generated logo for agentic-stack

agentic-stack

Memory framework

First committed by codejunkie99

Published in codejunkie99/agentic-stack. Publisher page

2,314 GitHub stars

What it is

One brain, many harnesses. Portable .agent/ folder (memory + skills + protocols) that plugs into Claude Code, Cursor, Windsurf, OpenCode, OpenClaw, Hermes, or DIY Python — and keeps its knowledge when you switch.
— the description by codejunkie99

Summary from the brain’s metadata

One brain, many harnesses. Portable .agent/ folder (memory + skills + protocols) that plugs into Claude Code, Cursor, Windsurf, OpenCode, OpenClaw, Hermes, or DIY Python — and keeps its knowledge when you switch. Keep one portable memory-and-skills layer across coding-agent harnesses, so switching tools doesn't reset how your agent works.

How it works

Memory model: SQL database

AutoGineer overview, from the brain’s own files

Memory model: SQL database. Folders: .cursor (agent config, 9 files); docs (docs, 49 files); examples (examples, 7 files); scripts (scripts, 2 files); tests (tests, 26 files). The agent reads .cursor/skills/caveman/SKILL.md. The agent writes .agent/memory/personal/PREFERENCES.md, .agent/skills/tldraw/.

Folders
FolderRoleFiles
.cursoragent-config9
docsdocs49
examplesexamples7
scriptsscripts2
teststests26
.agentfolder102
Formulafolder1
adaptersfolder47
harness_managerfolder31
schemasfolder13

The agent reads

The agent writes

Requirements

Runtimes: Python

Databases: PostgreSQL

API keys (by name): ANTHROPIC_API_KEY, MINIMAX_API_KEY, OPENAI_API_KEY

Works with: Claude Code, Cursor

Set it up

  1. This brain runs code automatically: 3 scripts. Review harness_manager/install.py, install.ps1, install.sh before opening the folder in Claude Code. No step below turns a hook on for you.

    • harness_manager/install.py: python harness_manager/install.py
    • install.ps1: pwsh install.ps1
    • install.sh: sh install.sh
  2. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/codejunkie99/agentic-stack/blob/11a75e16b6cb08a436b3124474273fdb9f08b4de/README.md#already-installed
  3. Not scanned by AutoGineerThe author’s README also describes installing it with Homebrew (the author’s own tap). Read its install section: AutoGineer did not scan that path. https://github.com/codejunkie99/agentic-stack/blob/11a75e16b6cb08a436b3124474273fdb9f08b4de/README.md#once-installed-manage-whats-wired
  4. Not scanned by AutoGineerThe author’s README also describes installing it with Homebrew (the author’s own tap). Read its install section: AutoGineer did not scan that path. https://github.com/codejunkie99/agentic-stack/blob/11a75e16b6cb08a436b3124474273fdb9f08b4de/README.md#quickstart
  5. Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/codejunkie99/agentic-stack/blob/11a75e16b6cb08a436b3124474273fdb9f08b4de/README.md#quickstart
  6. First committed by codejunkie99. Published in codejunkie99/agentic-stack. Licence: Apache License 2.0.

Usage

From the brain’s own files

  • After the first ./install.sh ‹adapter›, manage your project with verb-style subcommands (works with both install.sh and install.ps1):
  • PowerShell uses the same verbs, for example .\install.ps1 dashboard.
  • Bare ./install.sh (no arguments) opens a multi-select wizard on a fresh project — check every harness you actually use, hit enter, each one gets installed.
  • The wizard auto-detects harnesses already on disk and pre-checks them.
  • On a project that already has an install.json, bare interactive ./install.sh opens the dashboard.
  • In non-TTY shells (CI), it stays script-safe and prints the available subcommands instead of opening a TUI.
  • Upgrading from pre-v0.9?
  • Run ./install.sh doctor first — it synthesizes install.json from on-disk adapter signals so the new backend can track them.

Documentation by codejunkie99

agentic-stack

Keep one portable memory-and-skills layer across coding-agent harnesses, so switching tools doesn't reset how your agent works.

A portable .agent/ folder (memory + skills + protocols) that plugs into Claude Code, Cursor, Windsurf, OpenCode, OpenClaw, GitHub Copilot CLI, Google Gemini CLI, Hermes, Pi Coding Agent, Codex, Autohand Code CLI, Antigravity, or a DIY Python loop — and keeps its knowledge when you switch.

It also includes a local data layer so you can monitor the whole suite of agents from one place: harness activity, cron runs, active agents, token/cost estimates, KPI summaries, user-defined resource categories, and screenshot-ready daily dashboards.

<p align="center"> <img src="docs/data-layer.svg" alt="agentic-stack data layer dashboard flow" width="880"/> </p>

And it can turn approved, redacted runs into local flywheel artifacts: trace records, context cards, eval cases, training-ready JSONL, and readiness metrics without training a model or sending telemetry.

<p align="center"> <img src="docs/demo.gif" alt="agentic-stack demo" width="880"/> </p>

<p align="center"> <img src="docs/diagram.svg" alt="agentic-stack architecture" width="880"/> </p>

New in v0.20.0 — orchestration, gated evolution, Markdown memory tracks

The brain now covers orchestration, self-evolution, and portable memory in the same file-backed, stdlib-only, host-agent-reviewed style:

  • DAG orchestration — plan.py validates a goal as a dependency graph, matches nodes to agents from protocols/agents.json (Claude Code, Codex, OpenCode, Gemini, Copilot, Pi, Hermes, OpenClaw, shell, custom), dispatches with bounded subprocesses, judges completion by evidence (exit status, truncation, NEED_INPUT: markers, per-node verify), writes exception reports with three resolutions (continue / abandon / replan), keeps every prompt, output, transcript and verdict on disk, and lets later runs consume earlier nodes via ref:. Playbooks save a run as a template; personas assemble a lead role plus specialist roster; campaigns run unattended with a model-free monitor and a report gate. → docs/orchestration.md

  • Gated evolution — four strategy seats (memory / planning / capability / action) around the conductor, and evolve.py: diagnose failures from episodic memory, scaffold a candidate, paired screen on a fixed task sample (validity + activation gates, t ≥ 1.96), gene bank per (where, pathology) cell, install with backup. Nothing unscreened touches the live harness. → docs/evolution.md

  • Markdown memory tracks — episodes (user), agent cases, foresight with a validity window, weekly model-free reflection that consolidates and deprecates (never deletes), source-backed knowledge pages, a stdio MCP server (mem_context, mem_search, mem_save_turn, mem_save_fact, mem://profile, mem://search) for any host, and Claude Code SessionStart / UserPromptSubmit / Stop / SessionEnd hooks. → docs/memory-tracks.md

  • Skill forge — task-aware retrieval fused across local, memory-derived and hub catalogs; quality facets with issue flags and admission rules; explicit, validated update operations with lineage; task-intent clustering of agent cases into candidate skills.

  • One CLI contract — every new tool emits {"ok", "data", "meta"} / {"ok": false, "error": {...}} when piped, uses stable exit codes, and redacts credentials on the way out. sync.py moves the brain between devices over git. → docs/contracts.md

  • An agent can install the stack by reading docs/agent-install/SKILL.md.

python3 .agent/tools/plan.py validate --file plan.json && python3 .agent/tools/plan.py new --file plan.json
python3 .agent/tools/plan.py run <run_id> --yes && python3 .agent/tools/plan.py report <run_id>
python3 .agent/tools/evolve.py diagnose && python3 .agent/tools/evolve.py screen <cid> --n 4
python3 .agent/tools/track.py search episode "supabase migration"
claude mcp add agentic-memory -- python3 "$PWD/.agent/tools/memory_mcp.py"
New in v0.19.1 — memory and upgrade fixes

Patch release. Four correctness fixes:

  • Recall skips superseded lessons. Retrieval and rendering now share one superseded_by_map, so recall no longer returns stale guidance next to its replacement.

  • upgrade copies loop skills to the right path. New loop-* skills landed at .agent/skills/skills/loop-x/; they now land at .agent/skills/loop-x/.

  • UTF-8 everywhere in learn.py. Non-ASCII claims print and persist correctly regardless of host locale.

  • No leaked file handle when checking whether a lesson was already appended.

Bounded agentic loops (v0.19.0)

Portable loop contracts live under .agent/loops and use a maker → deterministic verifier → independent checker lifecycle:

agentic-stack loop init /path/to/your-project
agentic-stack loop validate /path/to/your-project
agentic-stack loop run ci-sweeper "make the failing test green" /path/to/your-project --yes
agentic-stack loop status /path/to/your-project

L2/L3 action loops use owned Git worktrees, finite attempts/runtime/output/token budgets, deny-path gates, resumable checkpoints, and privacy-safe local events. The supervisor bounds and audits child processes; it is not an operating-system sandbox. Use harness-native sandboxes and approvals for stronger isolation. Schedulers should invoke one bounded loop run command at a time and inspect its exit status before starting another run.

Earlier releases — Brain memory bridge (v0.18.0), Mission Control and lesson retraction (v0.17.0), safe project upgrades (v0.16.0), data layer and flywheel (v0.11.0), harness manager (v0.9.0) — are in CHANGELOG.md.

Image: GitHub release Image: License: Apache 2.0 Made by https://x.com/Av1dlive

Quickstart

macOS / Linux
# tap + install (one-time — both lines required)
brew tap codejunkie99/agentic-stack https://github.com/codejunkie99/agentic-stack
brew install agentic-stack

# drop the brain into any project — the onboarding wizard runs automatically
cd your-project
agentic-stack claude-code
# or: cursor | windsurf | opencode | openclaw | copilot-cli | gemini | hermes | pi | codex | autohand-code | standalone-python | antigravity
Windows (PowerShell)
# clone + run the native installer
git clone https://github.com/codejunkie99/agentic-stack.git
cd agentic-stack
.\install.ps1 claude-code C:\path\to\your-project
Already installed?
brew update && brew upgrade agentic-stack
agentic-stack dashboard
Clone instead?
git clone https://github.com/codejunkie99/agentic-stack.git
cd agentic-stack && ./install.sh claude-code         # mac / linux / git-bash
# or on Windows PowerShell: .\install.ps1 claude-code
# adapters: claude-code | cursor | windsurf | opencode | openclaw | copilot-cli | gemini | hermes | pi | codex | autohand-code | standalone-python | antigravity
Once installed: manage what's wired

After the first ./install.sh <adapter>, manage your project with verb-style subcommands (works with both install.sh and install.ps1):

./install.sh dashboard           # TUI dashboard: health, verify, memory, team, skills, instances
./install.sh mission-control     # beta local web dashboard; Ctrl-C turns it off
./install.sh brain status        # optional external Brain CLI integration
./install.sh add cursor          # add a second adapter (Claude Code + Cursor in same repo)
./install.sh status              # one-screen view: which adapters, brain stats
./install.sh doctor              # read-only audit; green / yellow / red per adapter
./install.sh manage              # interactive TUI: header pane + menu loop for add/remove/audit
./install.sh transfer            # onboarding-style wizard: export/import memory as a curl bridge
./install.sh upgrade --dry-run   # preview safe .agent infrastructure refresh
./install.sh upgrade --yes       # copy latest harness/memory/tools + new skills
./install.sh sync-manifest       # rebuild .agent/skills/_manifest.jsonl from SKILL.md frontmatter
./install.sh remove cursor       # confirm prompt + delete; no quarantine, no undo

PowerShell uses the same verbs, for example .\install.ps1 dashboard.

Bare ./install.sh (no arguments) opens a multi-select wizard on a fresh project — check every harness you actually use, hit enter, each one gets installed. The wizard auto-detects harnesses already on disk and pre-checks them. On a project that already has an install.json, bare interactive ./install.sh opens the dashboard. In non-TTY shells (CI), it stays script-safe and prints the available subcommands instead of opening a TUI.

Upgrading from pre-v0.9? Run ./install.sh doctor first — it synthesizes install.json from on-disk adapter signals so the new backend can track them. Installing on top without migration would orphan the prior installs.

Upgrading an already-installed project after brew upgrade? Run agentic-stack upgrade --dry-run in the project first, then agentic-stack upgrade --yes to refresh only skeleton-owned .agent infrastructure (harness/**/*.py, top-level memory/*.py, tools/*.py, the generated skill index, and new skill directories). It does not rewrite CLAUDE.md, .claude/settings.json, personal/semantic/episodic/working memory, candidates, or existing skill directories. agentic-stack sync-manifest is available as a repair command if _manifest.jsonl drifts from installed SKILL.md files.

Optional: external Brain integration

codejunkie99/brain is the git-backed long-term memory binary and MCP server. agentic-stack now treats it as an optional external memory layer instead of vendoring its Rust workspace.

Install Brain first:

brew install codejunkie99/tap/brain

Then check or wire it from a project:

agentic-stack brain status
agentic-stack brain onboard --agents codex,cursor --yes
agentic-stack brain ask "auth decisions"
agentic-stack brain note "Use PKCE for local OAuth flows."
agentic-stack brain mcp-command

Installed .agent/ projects also get python3 .agent/tools/brain_bridge.py and a brain seed skill so host agents can query or write Brain memory when a task needs cross-harness long-term recall.

Onboarding wizard

If you ran bare ./install.sh (no adapter name), the wizard starts with a multi-select harness step: it lists all 13 adapters, pre- checks any it detects on disk, and installs each one you confirm with space + enter. After the install(s), the preferences flow runs.

If you ran ./install.sh <adapter> directly, only the preferences flow runs.

Either way, the preferences step populates .agent/memory/personal/PREFERENCES.md — the first file your AI reads at the start of every session — and writes a feature-toggle file at .agent/memory/.features.json.

Six preference questions (each skippable with Enter):

QuestionDefault
What should I call you?(skip)
Primary language(s)?unspecified
Explanation style?concise
Test strategy?test-after
Commit message style?conventional commits
Code review depth?critical issues only

Plus one Optional features step (opt-in, off by default):

FeatureDefault
Enable FTS memory search [BETA]no
Enable tldraw visual canvas [BETA]no

Flags:

agentic-stack claude-code --yes          # accept all defaults, beta off (CI/scripted)
agentic-stack claude-code --reconfigure  # re-run the wizard on an existing project

Edit .agent/memory/personal/PREFERENCES.md any time to refine your conventions, or .agent/memory/.features.json to flip feature toggles.

Transfer wizard

Move the portable parts of one project brain into Codex, Cursor, Windsurf, or a terminal-only project with the onboarding-style TUI:

./install.sh transfer

The wizard turns a plain-language intent into a transfer plan, lets you review target harnesses and memory scopes, blocks secret-like content before export, and emits a one-line curl command the next environment can run. For move my memory, it includes preferences, accepted lessons, skills, working memory, episodic/history logs, and candidate lessons. The importer unpacks the bundle, verifies its SHA-256 digest, merges preferences and accepted lessons, copies selected skills, restores selected memory files, and installs the matching adapter files.

For scripted handoff:

./install.sh transfer export --intent "move my preferences and lessons into Codex" --print-curl
./install.sh transfer import --payload-file transfer.txt --sha256 <digest> --target codex

Review protocol (host-agent CLI)

The nightly auto_dream.py cycle only stages candidate lessons. It does not mark anything accepted or modify semantic memory. Your host agent does the review in-session:

# list pending candidates, sorted by priority
python3 .agent/tools/list_candidates.py

# accept with rationale (required)
python3 .agent/tools/graduate.py <id> --rationale "evidence holds, matches PREFERENCES"

# reject with reason (required); preserves decision history
python3 .agent/tools/reject.py <id> --reason "too specific to generalize"

# requeue a previously-rejected candidate
python3 .agent/tools/reopen.py <id>

# retract an accepted lesson from future recall/context (append-only audit)
python3 .agent/tools/retract_lesson.py <lesson_id> --rationale "obsolete after migration"

Graduated lessons land in semantic/lessons.jsonl (source of truth) and are rendered to semantic/LESSONS.md. Rejected candidates retain full decision history so recurring churn is visible, not fresh. Retracted lessons stay in history with status=retracted but are excluded from proactive recall.

See docs/architecture.md for the full lifecycle.


What this is

Every guide shows the folder structure. This repo gives you the folder structure plus the files that actually go inside: a working portable brain with fourteen seed skills, four memory layers, enforced permissions, a nightly staging cycle, host-agent review tools, and adapters for multiple harnesses.

  • Memory — working/, episodic/, semantic/, personal/. Each layer has its own retention policy. Query-aware retrieval (salience × relevance); nightly compression into reviewable candidates.

  • Review protocol — auto_dream.py stages candidate lessons mechanically. Your host agent reviews them via CLI tools (graduate.py, reject.py, reopen.py) and commits decisions with a required rationale. No unattended reasoning, no provider coupling.

  • Skills — progressive disclosure. A lightweight manifest always loads; full SKILL.md files only load when triggers match the task. Every skill ships with a self-rewrite hook. The bundled design-md skill teaches agents to use a root DESIGN.md as the visual source of truth for UI and Google Stitch workflows.

  • Protocols — typed tool schemas, a permissions.md that the pre-tool-call hook enforces, and a delegation contract for sub-agents.

  • Data layer — local-only dashboard exports across every harness sharing .agent/: agent events, cron timelines, KPI summaries, tokens/cost estimates, task categories, harness mix, dashboard.html, and daily report handoff.

  • Data flywheel — approved, redacted runs can become trace records, context cards, eval cases, training-ready JSONL, and readiness metrics without training a model or sending telemetry.

Memory search [BETA]

Opt-in FTS5 keyword search over all memory documents:

# enable during onboarding (or set manually in .agent/memory/.features.json)
python3 .agent/memory/memory_search.py "deploy failure"
python3 .agent/memory/memory_search.py --status
python3 .agent/memory/memory_search.py --rebuild

Falls back to ripgrep (rg) if installed, then to grep — both restricted to .md / .jsonl so source files never pollute results. The index is stored at .agent/memory/.index/ and gitignored.

Repo layout

.agent/                         # the portable brain (same across harnesses)
├── AGENTS.md                   # the map
├── harness/                    # conductor + hooks (standalone path)
│   ├── dag.py                  # orchestration library (v0.20)
│   ├── seats.py                # memory / planning / capability / action seats (v0.20)
│   └── hooks/
│       ├── claude_code_session.py    # SessionStart / UserPromptSubmit / Stop / SessionEnd (v0.20)
│       ├── claude_code_post_tool.py  # rich PostToolUse logging (v0.8+)
│       ├── copilot_cli_post_tool.py  # Copilot CLI postToolUse logging
│       ├── pi_post_tool.py     # Pi tool_result logging
│       ├── pre_tool_call.py    # permissions enforcement
│       ├── post_execution.py   # log_execution() entry point
│       └── on_failure.py       # failure write + repeated-failure rewrite flag
├── memory/                     # working / episodic / semantic / personal
│   ├── auto_dream.py           # staging-only dream cycle
│   ├── cluster.py              # content clustering + pattern extraction
│   ├── promote.py              # stage candidates
│   ├── validate.py             # heuristic prefilter (length + exact duplicate)
│   ├── review_state.py         # candidate lifecycle + decision log
│   ├── render_lessons.py       # lessons.jsonl → LESSONS.md
│   ├── memory_search.py        # [BETA] FTS5 search (opt-in)
│   ├── tracks.py               # Markdown daily-log tracks: episodes / cases / foresight (v0.20)
│   ├── reflect_episodes.py     # weekly model-free consolidation (v0.20)
│   └── knowledge/              # source-backed topic pages (v0.20)
├── loops/                      # bounded loop contracts (budget, constraints, loops)
├── evolve/                     # eval task cards, runner, candidates, gene bank (v0.20)
├── playbooks/  personas/       # saved plans and assembled personas (v0.20)
├── skills/                     # _index.md + _manifest.jsonl + SKILL.md files (+ orchestrator, evolver)
├── protocols/                  # permissions + tool schemas + delegation
│   ├── agents.json             # agent registry: capability cards + execution adapters (v0.20)
│   └── hook_patterns.json      # user-owned high/medium-stakes regex (v0.8+)
└── tools/                      # host-agent CLI + memory_reflect + skill_loader
    ├── learn.py                # one-shot lesson teaching (stage + graduate)
    ├── recall.py               # surface lessons relevant to an intent
    ├── show.py                 # colorful brain-state dashboard
    ├── data_layer_export.py    # local cross-harness dashboard/data export
    ├── data_flywheel_export.py # approved runs -> traces/cards/evals/JSONL
    ├── brain_bridge.py         # bridge to external Brain CLI/MCP memory
    ├── list_candidates.py
    ├── graduate.py
    ├── reject.py
    ├── reopen.py
    └── retract_lesson.py       # append-only semantic lesson retraction

adapters/                       # one small shim per harness, each with adapter.json manifest
├── claude-code/   (CLAUDE.md + settings.json hooks — $CLAUDE_PROJECT_DIR wired, closes #18)
├── copilot-cli/   (AGENTS.md + .github/instructions/ + .github/hooks/ + .github/skills/ mirror)
├── cursor/        (.cursor/rules/*.mdc)
├── gemini/        (gemini.md + .gemini/skills mirror)
├── windsurf/      (.windsurf/rules/*.md + legacy .windsurfrules)
├── opencode/      (AGENTS.md + opencode.json)
├── openclaw/      (AGENTS.md + system-prompt include; auto-registers per-project agent)
├── hermes/        (AGENTS.md)
├── pi/            (AGENTS.md + .pi/skills symlink)
├── codex/         (AGENTS.md + .agents/skills symlink)
├── autohand-code/ (AGENTS.md + .autohand/skills symlink)
├── standalone-python/  (DIY conductor entrypoint)
└── antigravity/   (ANTIGRAVITY.md)

harness_manager/                # v0.9.0 manifest-driven Python backend
├── schema.py                   # adapter.json validator (path-safe on POSIX + Windows)
├── install.py                  # applies file entries per merge_policy
├── state.py                    # install.json read/write with fcntl/msvcrt locking
├── doctor.py                   # read-only audit + pre-v0.9 migration synthesis
├── remove.py                   # safe uninstall with shared-file detection + ownership handoff
├── dashboard_tui.py            # project dashboard for health/verify/memory/team/skills/instances
├── mission_control.py          # beta local web dashboard entrypoint
├── brain.py                    # optional external Brain CLI integration
├── mission_control_collectors.py
├── mission_control_render.py
├── mission_control_server.py
├── mission_control_static.py
├── post_install.py             # named built-ins (openclaw_register_workspace)
├── manage_tui.py               # interactive menu loop for add/remove/audit
├── transfer_tui.py             # onboarding-style memory transfer wizard
├── transfer_plan.py            # natural-language target/scope planning
├── transfer_bundle.py          # export/import bundle codec + merge logic
├── skill_manifest.py           # rebuilds skills/_manifest.jsonl from SKILL.md
├── upgrade.py                  # safe .agent infrastructure refresh
├── status.py                   # one-screen installed-adapter view
├── loops/                      # loop supervisor: runner, process, worktrees, storage
└── cli.py                      # argparse dispatcher for install.sh / install.ps1

docs/                           # architecture, getting-started, per-harness
tests/                          # pytest suite, incl. test_claude_code_hook.py (62 checks)
schemas/data-layer/             # local dashboard/event schemas
examples/data-layer/            # sanitized data-layer shapes
schemas/flywheel/               # data-flywheel artifact schemas
examples/flywheel/              # sanitized approved-run examples
install.sh                      # mac / linux / git-bash installer (thin Python dispatcher)
install.ps1                     # Windows PowerShell installer (thin Python dispatcher)
Formula/agentic-stack.rb        # Homebrew formula
CHANGELOG.md                    # per-version release notes (v0.1.0 onward)
onboard.py                      # onboarding wizard entry point
onboard_features.py             # .features.json read/write
onboard_ui.py                   # ANSI palette, banner, clack-style layout
onboard_widgets.py              # arrow-key prompts (text, select, confirm)
onboard_render.py               # answers → PREFERENCES.md content
onboard_write.py                # atomic file write with backup
verify_codex_fixes.py           # v0.8.0 regression checks

Supported harnesses

HarnessConfig file it readsHook support
Claude CodeCLAUDE.md + .claude/settings.jsonyes (PostToolUse, Stop)
GitHub Copilot CLIAGENTS.md + .github/instructions/*.instructions.mdyes (postToolUse, sessionEnd)
Cursor.cursor/rules/*.mdcno (manual reflect calls)
Google Gemini CLIgemini.md + .gemini/skills/no (manual reflect calls)
Windsurf.windsurf/rules/*.md + legacy .windsurfrulesno (manual reflect calls)
OpenCodeAGENTS.md + opencode.jsonpartial (permission rules)
OpenClawAGENTS.md (auto-injected) + per-project openclaw agents add --workspacevaries by fork
Hermes AgentAGENTS.md (agentskills.io compatible)partial (own memory)
Pi Coding AgentAGENTS.md + .pi/skills/ + .pi/extensions/yes (tool_result event)
CodexAGENTS.md + .agents/skills/no (manual reflect calls)
Autohand Code CLIAGENTS.md + .autohand/skills/no (manual reflect calls)
Standalone Pythonrun.py (any LLM)yes (full control)
AntigravityANTIGRAVITY.mdyes (system context)

Seed skills

  • skillforge — creates new skills from recurring patterns

  • memory-manager — runs reflection cycles, surfaces candidate lessons

  • git-proxy — all git ops, with safety constraints

  • debug-investigator — reproduce → isolate → hypothesize → verify

  • deploy-checklist — the fence between staging and production

  • design-md — uses Google Stitch-style DESIGN.md files as portable design-system context for UI, frontend, and component work

  • data-layer — exports local dashboard data, cron timelines, KPIs, and daily reports across harnesses

  • data-flywheel — approved runs into context cards, evals, redacted traces, training-ready JSONL, and flywheel metrics

  • tldraw — opt-in beta skill for live canvas diagrams with a local snapshot store under .agent/skills/tldraw/

  • brain — queries and writes the optional external Brain memory through brain_bridge.py

  • loop-triage / loop-verifier / loop-constraints / loop-guard — read .agent/loops contracts: read-only triage, deterministic verification, path and approval gates, and pause/budget/stagnation decisions

How it compounds

  1. Skills log every action to episodic memory.

  2. auto_dream.py clusters recurring patterns into candidate lessons.

  3. The host agent reviews candidates with graduate.py / reject.py.

  4. Graduated lessons append to lessons.jsonl; LESSONS.md re-renders.

  5. Future sessions load query-relevant accepted lessons automatically.

  6. on_failure flags skills that fail 3+ times in 14 days for rewrite.

  7. git log .agent/memory/ becomes the agent's autobiography.

  8. Data-layer exports turn local activity into dashboard-ready monitoring.

  9. Approved, redacted runs can be exported into .agent/flywheel/ artifacts for retrieval, evals, prompt shrinking, and optional future adapters.

Export approved runs into a data flywheel

Put sanitized human-approved runs in:

.agent/flywheel/approved-runs.jsonl

Then run:

python3 .agent/tools/data_flywheel_export.py

Outputs land in .agent/flywheel/exports/<date>/:

  • trace-records.jsonl

  • training-examples.jsonl

  • eval-cases.jsonl

  • context-cards/<domain>/<workflow>.md

  • flywheel-metrics.json

This is local-only and model-agnostic. It creates training-ready artifacts; it does not train a model.

See docs/data-flywheel.md.

Run the staging cycle nightly

crontab -e
0 3 * * * python3 /path/to/project/.agent/memory/auto_dream.py >> /path/to/project/.agent/memory/dream.log 2>&1

auto_dream.py resolves its paths absolutely and performs only mechanical file operations (cluster, stage, prefilter, decay). No git commits, no network, no reasoning — safe to run unattended.

Monitor your agent suite

Generate a local dashboard for all harnesses writing to the same .agent/ brain:

python3 .agent/tools/data_layer_export.py --window 30d --bucket day

Or let the injected data-layer skill pass the user's words through:

python3 .agent/tools/data_layer_export.py show me last 7 days by hour

Outputs land in .agent/data-layer/exports/<date>/, including dashboard.html, dashboard.tui.txt, and daily-report.md. The command also prints the onboarding-style terminal dashboard directly inside your coding tool. Optional local inputs let you add scheduled runs and categories:

.agent/data-layer/cron-runs.jsonl
.agent/data-layer/category-rules.json
.agent/data-layer/harness-events.jsonl

Use this to track crons by day, active agents, token/cost estimates by hour/day/week/month, harness mix across Claude/Hermes/OpenClaw/Codex/etc., success/error rates, run cadence, workflow breadth, and user-defined categories like personal, admin, work, financial, and coding. The data layer is local-only; screenshot delivery requires explicit user approval and a user-configured channel.

See docs/data-layer.md.

License

Original Agentic Stack code and documentation authored by Avidlive are licensed under the Apache License 2.0. Third-party components remain under their own licenses and are not relicensed by this repository. See the licensing guide and NOTICE.

Credits

Based on the article "The Agentic Stack" by @AV1DLIVE — follow for updates and collabs. Coded using Minimax-M2.7 in the Claude Code harness; PR review by Macroscope and Codex. Patterns from Gstack, Claude Code's memory system, and conversations in the agent-engineering community. Built with the hypothesis that harness-agnosticism is the point.

Star History

Image: Star History Chart

CHANGELOG.md

Changelog

All notable changes to this project.

The format follows Keep a Changelog, and the project adheres to Semantic Versioning.

[Unreleased]

[0.20.0] - 2026-10-11

Added
  • Mission Control: new Evolution tab (evolver state, candidates, gene-bank cells); Runs now lists DAG plan runs and proactive campaigns; Brain shows episode/foresight/case track counts.

  • DAG orchestration (.agent/harness/dag.py, .agent/tools/plan.py): plans as dependency graphs with typed produces/requires contracts, an agent registry (.agent/protocols/agents.json) with capability cards and shell-free execution adapters, local-complementarity validation, bounded dispatch, deterministic completion adjudication (exit status, timeout, empty or truncated output, NEED_INPUT: / MISSING_CREDENTIAL: markers, per-node verify), exception reports with continue / abandon / replan, decision deadlines, file-backed node records, a cross-run node registry with ref: reuse, run reports with untrusted-output fences, playbooks.

  • Personas (.agent/tools/persona.py): lead role + specialist roster with tools and permission checks; plan.py --persona restricts executors.

  • Campaigns (.agent/tools/proactive.py): persistent target / measurement / allowed actions / budget records, wake-ups, a model-free tick monitor with early wake on done_regex / diverge_regex, measurement-cited decisions, and a report gate (baseline required, no claims the recorded state contradicts).

  • Strategy seats (.agent/harness/seats.py, seats.json): the conductor now composes memory / planning / capability / action seats.

  • Evolver (.agent/tools/evolve.py, .agent/evolve/): diagnosis from episodic failures, candidate scaffolds, paired screening with validity and activation gates (λ = 1.96), rounds with stagnation / max-round stops, a gene bank per (where, pathology) cell with lineage, gated install with backups, eval task cards and a pluggable runner.

  • Markdown memory tracks (.agent/memory/tracks.py, .agent/tools/track.py): episodes, agent cases, foresight with validity windows; Markdown frontmatter, entry markers, daily ids, scoping keys, atomic locked writes, deprecation instead of deletion.

  • Reflection (.agent/memory/reflect_episodes.py): cosine scene formation with running-mean centroids, consolidation of clusters into one episode, deprecation of members, audit log, stable cluster ids.

  • Knowledge (.agent/tools/knowledge.py): documents → categorized, source-backed topic pages with taxonomy, search, patch, remove.

  • Memory MCP server (.agent/tools/memory_mcp.py): stdio JSON-RPC with stable mem_context, mem_search, mem_save_turn, mem_save_fact tools and mem://profile, mem://search resources.

  • Claude Code session hooks (.agent/harness/hooks/claude_code_session.py, adapter settings): SessionStart context, UserPromptSubmit recall, Stop turn capture, SessionEnd summaries.

  • Skill forge (.agent/tools/skill_forge.py): weighted-RRF retrieval across local / memory-derived / hub sources, quality facets with issue flags and admission rules, composite scoring with scripts/references bonuses, explicit validated update ops with lineage, task-intent clustering of cases and candidate-skill proposals.

  • CLI contract (.agent/tools/_cli.py, docs/contracts.md): JSON envelopes, error taxonomy, exit codes, credential redaction.

  • Sync (.agent/tools/sync.py): git-backed cross-device brain sync.

  • Skills orchestrator and evolver; memory-manager extended; docs orchestration.md, evolution.md, memory-tracks.md, contracts.md, agent-install/SKILL.md; upgrade ships the agent registry and evolver assets add-only.

Fixed
  • Claude Code hook leaked home paths and file content (#66, #67). Episodic entries now store project- or ~-relative paths (<external> otherwise), input key names, and character counts in place of raw edit/write content, raw tool_input dumps, and raw tool output or error text.

  • Loop event export copied arbitrary text (#64). data_layer_export.py redacts loop event/status/decision values outside the set the loop supervisor and agentic-stack-desktop write (including exhausted, failed_to_start, timed_out, phase_started, running) to unknown.

  • MiniMax ignored max_tokens (#65). The OpenAI-wire call now forwards it as max_tokens (max_completion_tokens does not exist in the minimum supported openai==1.40.0).

  • test_learn_episodic_mirror.py leaked module stubs (#65). Stubbed sys.modules entries are restored after import; candidate JSON is read as UTF-8.

Docs
  • README: seed-skill list and count (14), repo layout (loops/, Copilot/Pi hooks, tests/), Windsurf rule path, and install notes moved under "Once installed".

[0.19.1] — 2026-08-07

Patch release. Four correctness fixes in memory retrieval, project upgrade, and file I/O. No contract, CLI, or on-disk format changes; upgrading is optional.

Fixed
  • Recall returned superseded lessons (#60). Supersession appends a new id and never edits the old row, so recall._load_structured() kept surfacing retired guidance beside its replacement. superseded_by_map() moved to render_lessons.py and is now shared, so retrieval and rendering can't disagree about what is retired. Provisional supersessions still do not retire the old lesson.

  • upgrade copied new loop skills to a doubled path (#63). A genuinely missing loop-* skill landed at .agent/skills/skills/loop-x/ instead of .agent/skills/loop-x/, in both --dry-run reports and real copies.

  • Locale-dependent encoding in learn.py (#61). stdout/stderr are forced to UTF-8, and candidate JSON is written with an explicit encoding, so non-ASCII claims survive on hosts whose default codepage isn't UTF-8.

  • Leaked file handle (#62). _lesson_already_appended() now reads through a context manager instead of relying on refcounting to close the file.

Migration

None required. Run agentic-stack upgrade --dry-run, then agentic-stack upgrade --yes, to pick up the fixes in an installed project. Projects that previously upgraded into .agent/skills/skills/ can delete that stray directory; the correctly-placed skills are copied on the next upgrade.

Release

[0.19.0] — 2026-07-18

Adds portable, bounded agentic loops and a local meta-harness for resumable maker/verifier/checker work.

Added
  • Strict JSON loop contracts, executor profiles, constraints, budgets, and portable seed skills.

  • Atomic checkpoints, privacy-safe events, shell-free bounded subprocesses, owned Git worktrees, policy gates, stagnation breakers, and CLI lifecycle verbs (init, validate, run, resume, status, stop, cleanup, audit).

  • Read-only loop health in doctor/status/dashboard/Mission Control and hashed loop-event ingestion in the local data layer.

Safety
  • L2/L3 action loops require worktree isolation, deterministic verification, independent checker approval, finite budgets, and explicit approval before mutating or external-write profiles.

  • Runtime events omit task/prompt/command/output content by construction. The supervisor is not an operating-system sandbox; use harness-native isolation for hostile child processes.

Migration

Run agentic-stack upgrade --dry-run, then agentic-stack upgrade --yes in existing projects. Upgrade adds missing loop starters and skills but preserves authored contracts, runtime state, and existing loop skill directories.

Release
  • Tag v0.19.0 cut from the verified release commit.

  • GitHub release: https://github.com/codejunkie99/agentic-stack/releases/tag/v0.19.0

  • Tarball sha256: 825d667153e4d0ff16282d8d86100d7254682d600ee535c36709a876106563f1.

  • Formula verification: tests/test_transfer_scripts.py passed 5 tests and ruby -c Formula/agentic-stack.rb returned Syntax OK. This Homebrew version rejected local-path audit, refused the untrusted tap name, and only accepts installed formula names for brew test; no Homebrew audit/test pass is claimed.

[0.18.0] — 2026-05-10

Minor release. Adds first-class integration with the external Brain CLI/MCP memory system while keeping agentic-stack's project-local .agent/ runtime independent and optional.

Added
  • Brain integration. Adds agentic-stack brain ... and .agent/tools/brain_bridge.py so projects can use the external codejunkie99/brain CLI/MCP server as a git-backed long-term memory layer without vendoring the Rust workspace into agentic-stack.

  • Brain seed skill. Adds a brain skill that teaches host agents when to query or write Brain memory and how to avoid storing secrets.

Release

[0.17.0] — 2026-05-10

Minor release. Clears the open PR queue and ships new harness adapters, the Mission Control beta, semantic lesson retraction, and the consolidated pytest layout.

Added
  • GitHub Copilot CLI adapter. Installs AGENTS.md, .github/instructions/agentic-stack.instructions.md, .github/hooks/agentic-stack.json, and a .github/skills/ mirror so Copilot CLI can load the portable brain and run memory hooks.

  • Google Gemini CLI adapter. Installs gemini.md plus a .gemini/skills/ mirror for Gemini CLI projects.

  • agentic-stack mission-control. Adds a beta local web dashboard with a snapshot mode, local-only event store, static assets, collectors, renderer, and tests.

  • Semantic lesson retraction. Adds .agent/tools/retract_lesson.py so an accepted lesson can be marked status=retracted with a required rationale while preserving append-only lessons.jsonl history.

Changed
  • README, getting-started docs, POSIX installer help, and PowerShell installer help now list all 12 adapters and the Mission Control command.

  • Proactive recall now considers only the latest append-only state for each lesson id, excluding retracted lessons from future recall results.

  • LESSONS.md rendering deduplicates append-only lesson state by id so the rendered markdown reflects the current status without losing audit history.

  • Tests now live under tests/ with pytest.ini, including coverage for Copilot CLI, Gemini, Mission Control, upgrades, onboarding, and lesson retraction.

Release

[0.16.1] — 2026-05-10

Patch release. Ships the production-ready getting-started guide from PR #49 and fixes stale version text in the onboarding banner.

Changed
  • docs/getting-started.md now leads with the Homebrew install path while documenting source-checkout and PowerShell flows separately.

  • The guide now explains which commands are available through the global agentic-stack wrapper and which source-checkout users should run through ./install.sh.

  • The guide now documents current project-management verbs, including dashboard, status, doctor, upgrade, sync-manifest, add, remove, and manage.

Fixed
  • The onboarding banner now derives its displayed version from harness_manager.__version__ instead of showing stale v0.8.0 text.

Release

[0.16.0] — 2026-05-09

Minor release. Adds a safe installed-project upgrade path and repairs skill manifest drift so newly copied skills can trigger reliably after version upgrades.

Added
  • agentic-stack upgrade. Adds a safe project migration verb that refreshes skeleton-owned .agent infrastructure, copies new skills, supports --dry-run/--yes, and leaves adapter configs plus user memory untouched.

  • agentic-stack sync-manifest. Rebuilds .agent/skills/_manifest.jsonl from installed SKILL.md frontmatter so copied skills can trigger correctly.

Fixed
  • Install/add now re-sync the skill manifest when a project already has .agent/skills, preventing _index.md / _manifest.jsonl drift.

  • doctor now warns when Claude Code hook commands reference missing .agent Python files or when hook scripts are present but not wired in .claude/settings.json.

Migration

After upgrading the CLI, run agentic-stack upgrade --dry-run in installed projects to preview safe .agent infrastructure updates, then agentic-stack upgrade --yes to apply them. Run agentic-stack sync-manifest if a project's skill manifest needs repair without copying files.

Release

[0.15.0] — 2026-05-06

Minor release. Adds a production dashboard TUI for installed agentic-stack projects, with the trust-console inspection surface folded into the same user-facing entrypoint.

Added
  • agentic-stack dashboard / dash. Adds a terminal dashboard for project health, installed adapters, doctor checks, harness verification, memory, team brain, skills, managed instances, transfer, and local data exports.

  • Trust-console parity. The dashboard includes a per-harness verify matrix, team brain status/init, skills listing, active instance listing, accepted/rejected memory review, and memory_why() evidence lookup.

  • Plain renderer. agentic-stack dashboard --plain and non-TTY fallback produce a script-safe text dashboard for logs, agents, and tests.

  • Interactive dashboard coverage. Adds local tests for renderer output, CLI aliases, trust-console parity sections, non-TTY fallback, up/down navigation, refresh, quit, and Enter-open behavior.

Changed
  • Bare interactive agentic-stack / ./install.sh opens the dashboard when an existing .agent/install.json is present. Non-TTY shells keep printing command guidance instead of launching an interactive UI.

  • README, POSIX installer help, and PowerShell installer help now document the dashboard entrypoint.

Fixed
  • test_claude_code_hook.py now works both as a standalone validation script and as a pytest-collected module by providing a real mod fixture.

Migration

No migration required. Existing projects can run agentic-stack dashboard after upgrading. Re-run an adapter install only if you want the latest copied adapter guidance files in a project.

Release

[0.13.0] — 2026-05-02

Minor release. Adds an onboarding-style transfer wizard for moving a portable .agent brain into Codex, Cursor, Windsurf, or terminal-only projects with a generated curl/PowerShell import command.

Added
  • agentic-stack transfer wizard. Adds an onboarding-style TUI that parses natural-language requests such as move my memory into Codex, previews the target adapter files, asks for confirmation, and either generates an import command, applies locally, or both.

  • Portable transfer bundles. Adds canonical JSON + gzip + base64url bundles with SHA-256 verification. The importer merges preferences and accepted lessons idempotently, restores selected memory files, copies skills, records import metadata, and installs selected adapters through the existing harness manager.

  • Full memory intent. move my memory now means preferences, accepted lessons, skills, working memory, episodic/history logs, and candidate lessons. Data-layer exports, flywheel traces, runtime indexes, and caches stay out unless future scopes explicitly add them.

  • Curl and PowerShell bootstraps. Adds scripts/import-transfer.sh and scripts/import-transfer.ps1 so another terminal can import a transfer bundle without manually cloning the repo first.

Changed
  • Windsurf installs a modern .windsurf/rules/agentic-stack.md workspace rule and still writes legacy .windsurfrules for older Windsurf builds.

  • agentic-stack transfer export and agentic-stack transfer import provide non-interactive surfaces for scripts and CI-style handoff flows.

Fixed
  • Transfer export blocks secret-like content, including private keys and common API token patterns, before payload generation.

  • Fresh Codex imports now copy the full .agent brain before installing the Codex AGENTS.md and .agents/skills adapter wiring.

Migration

No migration required. Existing installs keep working. Run agentic-stack transfer from a project that already has .agent/ to create or import a transfer bundle.

Release

[0.12.0] — 2026-04-27

Minor release. Adds the opt-in tldraw seed skill for live canvas diagrams and a skill-local snapshot store. The feature stays beta and off by default.

Added
  • tldraw seed skill — live canvas diagrams. Adds .agent/skills/tldraw/SKILL.md with MCP tool guidance, shape constraints, and a self-rewrite hook for diagram, sketch, wireframe, flowchart, whiteboard, and architecture visualization prompts.

  • Skill-local snapshot store. Adds .agent/skills/tldraw/store.py with snapshot, list, load, and archive CLI/API support. Runtime output is local and gitignored under .agent/skills/tldraw/: snapshots.jsonl, snapshots/, and INDEX.md.

  • Opt-in feature flag. Onboarding now writes a tldraw beta feature flag, default off. The skill loader skips flagged skills unless .agent/memory/.features.json explicitly enables them.

  • Manual MCP config source. Adds adapters/_shared/tldraw-mcp.json as the canonical tldraw MCP config block users can merge into Claude Code, Cursor, or Antigravity after enabling the feature.

Changed
  • Seed skill count is now nine: skillforge, memory-manager, git-proxy, debug-investigator, deploy-checklist, design-md, data-layer, data-flywheel, and tldraw.

  • tldraw persistence is intentionally skill-local storage, not a fifth memory layer: it has no dream-cycle, clustering, recall, or semantic-memory lifecycle.

  • Default adapter installs no longer wire beta tldraw MCP config automatically.

Fixed
  • Updated the tldraw validation suite to target .agent/skills/tldraw/store.py instead of the removed .agent/memory/visual/visual_memory.py.

  • store.py renders INDEX.md while holding the JSONL lock so concurrent snapshots cannot leave the index stale.

  • Added coverage for feature-gated skill loading, no default MCP install, path traversal rejection, malformed JSONL recovery, same-second snapshot ids, and concurrent snapshots.

Migration

No migration required. Existing installs keep tldraw disabled until users opt in through onboarding reconfiguration or .agent/memory/.features.json.

Credits
  • PR #11 by @Siddharth11Roy, with review fixes and release prep by Codex.

Release

[0.11.2] — 2026-04-26

Patch release. Makes the data-layer dashboard easier to access from coding tools by turning the injected data-layer skill into the natural-language dashboard surface.

Added
  • Injected dashboard behavior. The data-layer skill now triggers on plain phrases such as "show me the dashboard", "what did my agents do", "agent status", and "usage report". When the model decides the user wants local agent activity, the skill tells it to render the terminal dashboard directly instead of making the user remember flags.

  • Natural-language exporter requests. The existing exporter now accepts requests such as python3 .agent/tools/data_layer_export.py show me last 7 days by hour. It maps common phrases to --window and --bucket; explicit flags still override the natural-language text for scripts and automation.

Changed
  • The terminal dashboard now uses the same rail/marker visual language as the onboarding flow while keeping dashboard.tui.txt plain text with no ANSI escape codes.

  • dashboard-summary.json records the natural-language request that produced the export when one was provided.

Migration

No migration required. Existing flag-based commands still work.

Release

[0.11.1] — 2026-04-26

Patch release. Makes the data-layer dashboard visible directly in coding-tool terminals and adds a visual SVG explainer for the data-layer flow.

Added
  • Terminal dashboard by default. The existing python3 .agent/tools/data_layer_export.py --window 30d --bucket day command now prints a compact TUI-style dashboard after writing exports. It shows resource numbers, latest bucket activity, top harnesses, top workflows, top categories, and artifact paths without requiring a browser.

  • dashboard.tui.txt. The same terminal dashboard is saved next to dashboard.html, CSV/JSON exports, and daily-report.md for agents and users who want to inspect or attach a plain-text report.

  • docs/data-layer.svg. README and docs/data-layer.md now include a visual of the local data-layer flow: input streams, exporter, browser dashboard, terminal dashboard, CSV/JSON, and approved handoff.

Changed
  • dashboard-report.json now advertises the terminal dashboard artifact.

  • Data-layer docs no longer require a separate command to see the terminal view; the normal export command prints it.

Migration

No migration required. Existing data-layer commands still work; they now print the terminal dashboard in addition to the previous status lines.

Release

[0.11.0] — 2026-04-26

Minor release. Adds two local-first data capabilities: a cross-harness monitoring/data layer and an approved-run data flywheel. Both stay private by default, write regenerated runtime artifacts under ignored .agent/ subdirectories, and avoid remote telemetry or model training.

Added
  • data-layer seed skill — local cross-harness monitoring. Adds .agent/skills/data-layer/SKILL.md and .agent/tools/data_layer_export.py to export dashboard-ready local data across Claude Code, Hermes, OpenClaw, Codex, Cursor, OpenCode, and custom loops sharing the same .agent/ brain. Outputs include agent events, cron timelines, KPI summaries, token/cost estimates, category breakdowns, dashboard.html, and daily-report.md. Runtime exports live under .agent/data-layer/, which is gitignored. Thanks to @danielfoch for PR #25.

  • data-flywheel seed skill — approved runs to reusable artifacts. Adds .agent/skills/data-flywheel/SKILL.md and .agent/tools/data_flywheel_export.py to turn human-approved, redacted runs into trace records, context cards, eval cases, training-ready JSONL, and flywheel metrics. Runtime exports live under .agent/flywheel/, which is gitignored. The tool is local-only, model-agnostic, and does not train models or call external APIs. Thanks to @danielfoch for PR #26.

  • Schemas, sanitized examples, tests, README sections, and architecture docs for both local data features.

Changed
  • Seed skill count is now eight: skillforge, memory-manager, git-proxy, debug-investigator, deploy-checklist, design-md, data-layer, and data-flywheel.

  • docs/architecture.md now describes five local modules: memory, skills, protocols, data layer, and data flywheel.

Migration

brew upgrade agentic-stack is enough. There are no on-disk schema changes. The new runtime directories, .agent/data-layer/ and .agent/flywheel/, are private and regenerated; both are gitignored.

Release
Credits
  • PR #25 and PR #26 by @danielfoch.

  • Merge conflict resolution, verification, and release prep by Codex.

[0.10.0] — 2026-04-26

Minor release. Adds the design-md seed skill (sixth seed skill in the brain), and fixes a hard crash on macOS-default Python 3.9 that hit every brew user on first run.

Added
  • design-md seed skill — DESIGN.md / Google Stitch support. A new portable skill that points coding agents at a root DESIGN.md (Google Stitch format) as the visual-system source of truth. Loads only when DESIGN.md exists at the project root; default behavior is read-only on the contract file, and validation prefers npx @google/design.md lint DESIGN.md over hand-checks. Brings the seed skill count from five to six. Thanks to @danielfoch for the contribution (PR #21). Decision recorded in .agent/memory/semantic/DECISIONS.md.

Fixed
  • Python 3.9 crash on first run (#27). Every brew user on macOS-default Python 3.9 hit TypeError: unsupported operand type(s) for |: 'type' and 'type' immediately after brew install agentic-stack because harness_manager/ used PEP 604 union syntax (Path | str) that requires Python 3.10+ at runtime. Added from __future__ import annotations (PEP 563) to the eight affected files so all annotations are stored as strings and never evaluated at import time. Works on Python 3.7+, which covers every macOS-shipped Python in the wild. Zero-cost vs. the reporter's suggested [email protected] brew dep (~150 MB pull). Thanks to @WhoLsJohnGalt for the precise repro and the suggested workaround.

Migration

brew upgrade agentic-stack is enough — no on-disk schema changes. Users on Python 3.9 who hit #27 on v0.9.x can upgrade and the crash goes away. Users with existing .pi/extensions/memory-hook.ts from v0.9.0 already got the fixes via ./install.sh pi after the v0.9.1 upgrade; this release adds the design-md skill on top.

Release
  • Tag v0.10.0 cut from master.

  • GitHub release: https://github.com/codejunkie99/agentic-stack/releases/tag/v0.10.0

  • Formula/agentic-stack.rb bumped to v0.10.0 in a follow-up commit (same flow as v0.8.0 → v0.9.0 → v0.9.1): tag first, compute sha256, then bump url + sha256 + version together so brew always points at a real installable artifact.

Credits
  • PR #21 by @danielfoch (design-md skill), with cross-model review fixes applied as a follow-up commit.

  • Issue #27 by @WhoLsJohnGalt — clean repro of the macOS Python 3.9 crash including a working sed-based workaround.

[0.9.1] — 2026-04-26

Patch release that closes the gap between v0.9.0 and a working pi adapter. Every brew user on v0.9.0 hit the first bug; the rest are quieter but make the dream cycle and the cross-harness episodic log actually correct.

Fixed
  • agentic-stack pi crashed for every brew user with ModuleNotFoundError: No module named 'harness_manager'. The v0.9.0 Formula didn't include harness_manager/ in pkgshare.install, so install.sh couldn't dispatch. Adds it back.

  • Pi dream cycle never fired. The session_shutdown handler filtered on event.reason, but Pi's SessionShutdownEvent carries no reason field — verified against pi-coding-agent types.d.ts and the emit site at agent-session.js:1638. The filter rejected every event, so auto_dream.py never ran. Filter dropped; re-entrancy guard added.

  • Pi edit reflections lost the diff. Hook accessed event.input.edits[0] but Pi's EditToolInput is flat { path, oldText, newText } (no edits array — that's MultiEdit on Claude Code). Reflections silently degraded to Edited <path> with no old/new content. Read the flat fields.

  • decay.py crashed comparing aware-UTC entries to naive cutoff. The new session_shutdown hook surfaced this on every clean pi exit. Cutoff is now datetime.now(timezone.utc); entry timestamps are normalised to UTC before comparison.

  • Naive-local Python timestamps drifted against the UTC decay window. Decay's "naive == UTC" assumption was correct only if writers emitted UTC. They didn't: post_execution, on_failure, learn, graduate, promote, review_state, render_lessons all wrote naive-local. Every writer now emits aware UTC; every reader (salience, show._human_age / _daily_counts / failing_skills / last_dream_cycle, on_failure._count_recent_failures, review_state._age_factor, archive) normalises naive timestamps to UTC before comparison.

  • One bad regex in hook_patterns.json disabled every user pattern in the Pi hook. Pre-fix used a single combined RegExp per list, caught any error, returned null for both. Now per-fragment validation with incremental merge — same posture as claude_code_post_tool.py's _filter_valid / _build_with_fallback.

  • auto_dream lost entries that landed mid-cycle. Original _write_entries had a truncate-before-lock window — open(path, "w") truncates BEFORE a lock can be taken. The deeper bug: even after fixing the inner race, any append_jsonl() between _load_entries() and _write_entries(kept) would be truncated away by the rewrite. The cycle now holds a single exclusive flock on AGENT_LEARNINGS.jsonl across the entire read-modify-write window via _episodic_locked(). Mutually exclusive with _episodic_io.append_jsonl (same flock target). POSIX only; Windows falls back to historical best-effort behaviour.

  • _cachedSha went stale after git commit inside a pi session. TS hook cached the SHA per-process for performance, so every entry logged after a mid-session commit recorded the pre-commit SHA. Cache, but invalidate on bash commands matching git <subcmd> for HEAD-moving subcommands. Allows option flags between git and the subcommand (git -c key=val checkout main, git -C path switch dev).

  • salience over-scored future-skewed legacy rows. Legacy naive-local timestamps re-interpreted as UTC could read as a few hours in the future during the migration window. timedelta.days then went negative and recency exceeded the intended cap. Floor age at 0; clamp recency to ≤ 10.

  • decay archive filename used local date while cutoff was UTC. archive_{date}.jsonl now uses UTC date so a tz-jumping user gets a deterministic path.

Changed
  • adapters/pi/adapter.json no longer manages .agent/harness/hooks/pi_post_tool.py via from_stack. The TS hook is self-contained — all scoring + reflection inline, no Python subprocess per tool call. The .py still ships in the brain template under .agent/harness/hooks/ for standalone use.

  • tests/ is now untracked and listed in .gitignore. CI never ran these (.github/workflows/ci.yml runs test_claude_code_hook.py + verify_*.py at repo root). Pull from an older tag if you want the unittest suite locally.

Migration

brew upgrade agentic-stack is enough — there are no on-disk schema changes. Existing pi installs with the v0.9.0 hook get the new logic on the next ./install.sh pi. Existing .agent/memory/episodic/AGENT_LEARNINGS.jsonl files with naive-local timestamps continue to work — readers normalise them at compare time and writers emit UTC going forward.

Release
  • Tag v0.9.1 cut from master at d7b70b2.

  • GitHub release: https://github.com/codejunkie99/agentic-stack/releases/tag/v0.9.1

  • Formula/agentic-stack.rb bumped to v0.9.1 in a follow-up commit (same flow as v0.8.0 → v0.9.0): tag first, compute sha256, then bump url + sha256 + version together so brew always points at a real installable artifact.

  • Tarball sha256: 09cc3b8c9ec159cf8b85cf672fc15a29e6bfa9377cc9c59dd270acd441ced568 (verify locally with curl -sL https://github.com/codejunkie99/agentic-stack/archive/refs/tags/v0.9.1.tar.gz | shasum -a 256)

Credits

PR #24 by @aliirz; Codex CLI used for an independent second-opinion review that surfaced the auto_dream window race + the SHA-regex narrowness.

[0.9.0] — 2026-04-23

Added
  • Harness manager: manifest-driven adapter system. Each adapter now ships an adapters/<name>/adapter.json declaring its files, collision policy, optional skills directory mirror, and named post-install actions. Adding a new adapter is now a JSON-only PR — no Python code, no test wiring, no class registration. Lives in the new harness_manager/ Python package.

  • ./install.sh add <adapter> — append an adapter to an existing project without re-running the onboarding wizard.

  • ./install.sh remove <adapter> — confirmation prompt lists every file before deletion. Hard delete (no quarantine, no undo — git is the safety net). Reverses post-install actions automatically (e.g., openclaw agents remove).

  • ./install.sh doctor — read-only audit of installed adapters. Verifies tracked files exist, post-install state is valid, .agent/ brain is intact. Exits 0 on green, 1 on red. First run on a pre-v0.9.0 project asks before synthesizing install.json — never silently mutates.

  • ./install.sh status — one-screen view of installed adapters, brain stats (skills/episodic/lessons), last-updated timestamp.

  • .agent/install.json — authoritative record of what's installed. Schema-versioned. Atomic write via tempfile + rename, fcntl-locked on POSIX.

  • PowerShell parity from day one. install.ps1 is now a 70-line thin dispatcher to the same Python backend install.sh uses. The new add/remove/doctor/status verbs behave identically across mac/Linux/Windows. Was 270+ lines of duplicated bash-shaped logic.

  • docs/per-harness/standalone-python.md — gap-fill for the only harness that didn't have a per-harness doc.

Fixed
  • #18 — Claude Code hook commands break when cwd is not the project root. adapters/claude-code/settings.json template now uses {{BRAIN_ROOT}} placeholder, which the manifest backend substitutes with $CLAUDE_PROJECT_DIR at install time. Hook commands resolve correctly regardless of which directory Claude Code's cwd points at. Thanks to @palamp for the report and the proposal that shaped the larger feature.

Security
  • Manifest path-safety hardening (harness_manager/schema.py). The pre-existing path-traversal guard only tokenized on / and only treated /-prefixed paths as absolute, so Windows-style inputs (..\..\outside, \\server\share, C:\temp\x, C:foo) bypassed validation and could let install/remove read or write outside the adapter/project roots when run on Windows. Also extended the same validation to skills_link.target and skills_link.dst, which were previously only checked for presence — a manifest could otherwise point the symlink/rsync into arbitrary filesystem locations on any platform. Both POSIX and Windows separators are now normalized before traversal detection, and every common absolute-path form (POSIX root, Windows root, UNC, drive-letter) is rejected.

Changed
  • install.sh shrinks from 175 lines of bash case-statements to 35 lines of dispatcher. All install logic moved to harness_manager/. Existing CLI surface preserved: ./install.sh <adapter> [target] [--yes|--reconfigure|--force] works identically.

  • install.ps1 shrinks from 270+ lines to 70.

Migration

Existing v0.8.x users: brew upgrade agentic-stack, then run ./install.sh doctor in your project. Doctor detects existing adapters from filesystem signals and asks before writing install.json. Subsequent doctor runs are read-only.

Release checklist (post-merge, pre-brew upgrade)

The Homebrew Formula (Formula/agentic-stack.rb) intentionally still points at the v0.8.0 tarball in this PR. The v0.9.0 release flow is:

  1. Merge this PR to master.

  2. Tag v0.9.0 on master and create the GitHub release.

  3. Run curl -L https://github.com/codejunkie99/agentic-stack/archive/refs/tags/v0.9.0.tar.gz | shasum -a 256 to compute the new sha256.

  4. Open a follow-up PR that updates url, sha256, version together, and adds harness_manager + install.ps1 to the pkgshare.install line. This is the same pattern as commit abaa352 (the v0.8.0 sha256 bump).

Reason for the split: a Formula change that adds harness_manager/ to pkgshare.install while still pointing at the v0.8.0 tarball would fail brew install (file-not-found in the staged tarball). Bumping all four fields together as a follow-up after the tag exists keeps the formula always pointing at a real, installable artifact.

0.8.0 — 2026-04-21

Added
  • Google Antigravity adapter. ./install.sh antigravity drops an ANTIGRAVITY.md into the project root so Antigravity agents pick up the portable brain in .agent/. Matches the pattern of the other root-instruction harnesses. Brings the supported-harness count to 9. Thanks to @smartsastram for the contribution (PR #9).

  • Rich PostToolUse episodic logging for Claude Code. New .agent/harness/hooks/claude_code_post_tool.py reads the JSON payload Claude Code sends via stdin and derives a real action label, importance score, and non-empty reflection per tool call. Replaces the old hardcoded post-tool ok that produced identical entries every session and left the dream cycle with nothing to cluster on. Ships with a 54-test validation suite (test_claude_code_hook.py). Thanks to @aliirz for the contribution (PR #8).

  • User-owned stack tuning via hook_patterns.json. Drop your own high-stakes and medium-stakes command patterns in .agent/protocols/hook_patterns.json so the hook scores vercel deploy, supabase migrate, etc. correctly for your stack. Ships with empty arrays and a _examples section; universal patterns stay hardcoded.

  • on_failure() severity overrides. New importance= and pain_score= parameters so a failed production deploy records its real severity instead of the flat importance=7 / pain_score=8 defaults. Lets the dream-cycle salience formula actually distinguish a failed migration from a failed ls.

  • Bash wrapper-aware failure detection. _is_success() now detects explicit exit-masking wrappers (|| true, || :, || exit 0, ; true) and falls through to stderr-based signal when they are present, so masked production failures are still captured. Quoted strings and set +e are excluded from masking detection to avoid false positives on patterns like echo '... || true ...' and set +e; grep X log; set -e.

  • 33-check regression verifier. verify_codex_fixes.py validates every classification path after 7 rounds of codex review. Named verify_*.py (not test_*.py) to avoid pytest collection side effects. Uses a TMPDIR / $HOME / repo-local / VERIFY_TMPDIR fallback chain so it runs in constrained sandboxes.

Fixed
  • Bash exit_code=0 no longer second-guessed via stdout. Commands like grep Error /var/log/app.log and cat failures.log used to be recorded as failures because the output contained error-looking strings. Exit code is now authoritative for Bash responses.

  • User regex fragments in hook_patterns.json can't crash the hook. Each fragment is validated standalone via re.compile; invalid ones are dropped with a stderr warning. Merged-compile failures (e.g., a fragment like (?i)foo that validates alone but breaks once embedded) fall back to an incremental build that drops only the offending fragments, preserving universals and good user fragments.

  • on_failure reflection no longer prefixes str: for string errors. Only Exception objects get a type-name prefix now.

Changed
  • Wizard version bumped to 0.8.0 in onboard_render.py.

  • Wizard outro now points users at .agent/protocols/hook_patterns.json so they know they can extend the importance scorer with their stack's service names.

0.7.2 — 2026-04-20

Changed
  • README repositioning. Leads with the actual buyer pain — switching coding-agent tools keeps resetting how your agent behaves — so the adapter list, wizard, and memory architecture read as proof instead of preamble. Follow / coded-using / article framing moved into the Credits section.

0.7.1 — 2026-04-20

Changed
  • Relicensed from MIT to Apache 2.0.

0.7.0 — 2026-04-20

Added
  • learn.py host-agent tool. Teach the agent a rule in one command: python3 .agent/tools/learn.py "Always serialize timestamps in UTC" --rationale "past cross-region bugs". Stages, graduates, and renders in one step. Idempotent. Cleans up staged files on heuristic reject; preserves on crashes so retries work.

  • recall.py host-agent tool. Surfaces graduated lessons relevant to what you're about to do. Ranked lexical-overlap hits with per-entry source labels. Merges lessons.jsonl and seed bullets in LESSONS.md so graduating your first lesson doesn't hide the seeds. Logs every recall to episodic memory for audit.

  • show.py host-agent tool. Colorful dashboard of brain state (episodes, candidates, lessons, failing skills, 14d activity sparkline). --json / --plain / NO_COLOR flags.

  • Adapter wiring for recall across all 8 harnesses. Every adapter (claude-code, cursor, windsurf, opencode, openclaw, hermes, pi, standalone-python) now instructs the model to run recall.py "<intent>" before deploy / migration / timestamp / debug / refactor work, and to surface results in a Consulted lessons before acting: block.

  • Pre-graduated seed UTC lesson so new installs see proactive recall return a real hit on first try. Stored at .agent/memory/semantic/lessons.jsonl.

Fixed
  • Canonical pattern_id. Conditions are casefolded, unicode whitespace collapsed, zero-widths stripped, deduped, sorted — the same logical set always yields the same id.

  • Stricter heuristic check. validate.heuristic_check now requires ≥3 content words in a claim (blocks junk like !!!abc that passed the raw-length gate).

  • Idempotent graduate.py retries. Re-renders LESSONS.md, honors original reviewer / rationale from lessons.jsonl to keep stores in sync, refuses retries against legacy rows missing metadata.

  • Advisory flock on lessons.jsonl. render_lessons and append_lesson now hold an exclusive flock during writes. Concurrent writers serialize; LESSONS.md can no longer go stale relative to lessons.jsonl. Atomic rewrite via temp file + rename.

0.6.0 — 2026-04-17

Added
  • Pi Coding Agent adapter. ./install.sh pi drops AGENTS.md and symlinks .pi/skills to .agent/skills so pi sees the full brain with zero duplication. Safe to install alongside hermes / opencode (all read AGENTS.md; the installer skips the overwrite if one exists).

Changed
  • BREAKING: openclient adapter renamed to openclaw. Installed file changed: .openclient-system.md → .openclaw-system.md. Existing OpenClient users: re-run ./install.sh openclaw.

0.5.0 — 2026-04-17

Added
  • Host-agent review protocol. Python handles filing (cluster, stage, heuristic prefilter, decay). The host agent handles reasoning via list_candidates.py / graduate.py / reject.py / reopen.py. Graduation requires --rationale so rubber-stamping is structurally impossible. Zero unattended reasoning, zero provider coupling.

  • Structured lessons.jsonl as source of truth. LESSONS.md is rendered from it. Hand-curated content above the sentinel is preserved across renders; legacy bullets auto-migrate on first run.

  • Proper single-linkage clustering with bridge-merge. Pattern IDs derived from canonical claim + conditions, stable across cluster- membership changes, distinct for generic-canonical collisions.

  • Query-aware retrieval. context_budget ranks episodes by salience × relevance and filters lessons to status=accepted only — provisional, legacy, and superseded entries never leak into the system prompt.

  • [BETA] FTS5 memory search (.agent/memory/memory_search.py). Opt-in via onboarding or .agent/memory/.features.json. Default off. Prefers ripgrep when FTS5 is not available, falls back to grep. Restricted to .md / .jsonl so source files never pollute results.

  • Windows-native installer. install.ps1 runs natively under PowerShell; install.sh continues to work under Git Bash / WSL.

Fixed
  • Batch-sound graduation gate.

  • Stable slugs across cluster drift.

  • Provisional re-review and supersession semantics.

  • REVIEW_QUEUE refreshes on every CLI action.

  • Heuristic-rejection stamping so unrelated LESSONS.md edits do not churn.

  • Atomic graduate.py (semantic write first, candidate move last).

  • .gitignore ordering so .agent/memory/.index/ is actually ignored.

  • Fallback search restricted to .md / .jsonl.

  • Feature toggle file and [BETA] label in onboarding.

0.4.0 — 2026-04-16

Added
  • Interactive onboarding wizard (onboard.py, clack-style UI) that auto-fills PREFERENCES.md after install. Flags: --yes (CI / defaults), --reconfigure (re-run). Apple-style redesign with 7 scenes (Memory, Skills, Dream Cycle added).

0.3.0 — 2026-04-16

Fixed
  • Cron-safe paths in auto_dream.py and Stop hook matcher.

  • Deny-glob syntax in settings.json.

0.2.0 — 2026-04-16

Added
  • Homebrew formula at Formula/agentic-stack.rb.

Fixed
  • standalone-python path detection.

  • Harness count in README.

  • brew tap URL in README.

0.1.0 — 2026-04-16

Added
  • Initial release. Portable .agent/ brain folder with adapters for Claude Code, Cursor, Windsurf, OpenCode, OpenClient (later OpenClaw), Hermes, and standalone Python. Homebrew installer (replaces the earlier npx-based flow).

307 files · 287 not served here

Advantages

  • Local-first: the memory stays in files or a database on your own machine (a rule-derived fact from the brain’s files, evidence: README.md)
  • Open licence (Apache-2.0) (a rule-derived fact from the brain’s files)

Limitations

  • Needs an API key (ANTHROPIC_API_KEY, MINIMAX_API_KEY, OPENAI_API_KEY) (a rule-derived fact from the brain’s files, evidence: README.md)
  • Needs a database (PostgreSQL) (a rule-derived fact from the brain’s files, evidence: README.md)
  • Runs code automatically: review what it runs before you open it (a rule-derived fact from the brain’s files)
  • No ZIP download: install it from its source (a rule-derived fact from the brain’s files)

Security

Risk level: Medium risk

This brain runs

Agent instructions that run or fetch something (102)

  • .agent/AGENTS.md: `python .agent/tools/list_candidates.py` — pending candidates, sorted by priority
  • .agent/AGENTS.md: `python .agent/tools/graduate.py <id> --rationale "..."` to accept
  • .agent/AGENTS.md: `python .agent/tools/reject.py <id> --reason "..."` to reject
  • .agent/AGENTS.md: `python .agent/tools/reopen.py <id>` to requeue a previously-rejected item
  • .agent/AGENTS.md: `tools/plan.py` — validate / new / run / resolve / report;
  • .agent/AGENTS.md: `tools/evolve.py` — diagnose → scaffold → screen (paired, gated) → round → install;
  • .agent/AGENTS.md: **Run before deploy / migration / timestamp / debug / refactor work.** This is how lessons cross harnesses.
  • .agent/skills/brain/SKILL.md: python3 .agent/tools/brain_bridge.py status
  • .agent/skills/brain/SKILL.md: If Brain is missing, tell the user to install it:
  • .agent/skills/brain/SKILL.md: brew install codejunkie99/tap/brain
  • .agent/skills/brain/SKILL.md: python3 .agent/tools/brain_bridge.py ask "<intent or topic>"
  • .agent/skills/brain/SKILL.md: python3 .agent/tools/brain_bridge.py note "<one durable observation>"
  • .agent/skills/brain/SKILL.md: python3 .agent/tools/brain_bridge.py mcp-command
  • .agent/skills/data-flywheel/SKILL.md: approved run
  • .agent/skills/data-flywheel/SKILL.md: Each line should be a sanitized run record with:
  • .agent/skills/data-flywheel/SKILL.md: Run:
  • .agent/skills/data-flywheel/SKILL.md: python3 .agent/tools/data_flywheel_export.py
  • .agent/skills/data-layer/SKILL.md: KPI summary rows for cron cadence, run volume, reliability, active agents, workflow breadth, token usage, and estimated cost
  • .agent/skills/data-layer/SKILL.md: python3 .agent/tools/data_layer_export.py show me last 7 days by hour
  • .agent/skills/data-layer/SKILL.md: If the user gives no range or bucket, run the default export.
  • .agent/skills/data-layer/SKILL.md: Run:
  • .agent/skills/data-layer/SKILL.md: python3 .agent/tools/data_layer_export.py --window 30d --bucket day
  • .agent/skills/data-layer/SKILL.md: Run the exporter from a user-approved cron or scheduled agent.
  • .agent/skills/debug-investigator/SKILL.md: **Verify.** After the fix, re-run the repro.
  • .agent/skills/deploy-checklist/SKILL.md: Run this checklist before any deploy.
  • .agent/skills/deploy-checklist/SKILL.md: If anything went wrong, run the debug-investigator loop and update this checklist with the new step that would have caught it.
  • .agent/skills/design-md/SKILL.md: npx @google/design.md lint DESIGN.md
  • .agent/skills/design-md/SKILL.md: npx @google/design.md diff DESIGN.before.md DESIGN.md
  • .agent/skills/design-md/SKILL.md: the manual fallback does not, so re-run the CLI when you regain network access.
  • .agent/skills/evolver/SKILL.md: No pass, no install;
  • .agent/skills/evolver/SKILL.md: `evolve.py install <cid>` — applies files to the live `.agent/` with a backup under `evolve/backups/`.
  • .agent/skills/evolver/SKILL.md: Pathology "rejected-tests-failing-before-push" in git-proxy → candidate edits `skills/git-proxy/SKILL.md` to run the test command before `git push` and prints `[evolved:pretest]`. · uses the network
  • .agent/skills/evolver/SKILL.md: Screen on 4 push-flavoured cards: gain 0.75, t=3.0 → pass → round → install.
  • .agent/skills/evolver/SKILL.md: A candidate "passed" with zero variance because the eval cards were all trivially solved by both harnesses after the first run (cached state in the overlay).
  • .agent/skills/git-proxy/SKILL.md: Stage specific files, not `git add -A` (avoids capturing secrets).
  • .agent/skills/git-proxy/SKILL.md: Run tests first.
  • .agent/skills/loop-constraints/SKILL.md: Read constraints and the run checkpoint before assessing a change.
  • .agent/skills/memory-manager/SKILL.md: Commit via git so history is preserved: `git log memory/` is the agent's autobiography.
  • .agent/skills/memory-manager/SKILL.md: python3 .agent/memory/memory_search.py <query>
  • .agent/skills/orchestrator/SKILL.md: node ids are unique across runs (reuse old output via `"inputs": {"x": "ref:<node_id>"}` instead of re-running).
  • .agent/skills/orchestrator/SKILL.md: `plan.py new --file plan.json` → run id.
  • .agent/skills/orchestrator/SKILL.md: `plan.py run <id>` stops at `awaiting_approval` when a node mutates the workspace;
  • .agent/skills/orchestrator/SKILL.md: When attempts run out, read `exceptions/<node>.json` (category, missing, evidence, blocked dependents, deadline).
  • .agent/skills/orchestrator/SKILL.md: replan --file` (a successor run;
  • .agent/skills/orchestrator/SKILL.md: `plan.py playbook save <run_id> --name <slug>` after a run that worked;
  • .agent/skills/orchestrator/SKILL.md: `validate`, `new`, `run` (approve), `report`.
  • .agent/skills/orchestrator/SKILL.md: After 5 runs or any run that ended `failed`: read the exception reports, check whether a missing `verify`, a wrong `needs`, or a bad prompt caused it, and propose a conservative edit to this file.
  • .agent/skills/tldraw/SKILL.md: This beta does not install MCP wiring during default adapter setup.
  • .agent/skills/tldraw/SKILL.md: python3 .agent/skills/tldraw/store.py snapshot \
  • .cursor/rules/fable-grok-subagents.mdc: Subagents run on Grok 4.6, pinned by `model: grok-4.6` in `.cursor/agents/*.md`.
  • .cursor/rules/fable-grok-subagents.mdc: | Job | Subagent | |---|---| | Locate, bulk grep, file discovery | `cavecrew-investigator` | | 1–2 file surgical edit | `cavecrew-builder` | | Diff review before commit or PR | `cavecrew-reviewer` | | Test loops and verbose shell runs | `cavecrew-builder` (edit, then run tests, report s …[+91 chars]
  • adapters/claude-code/CLAUDE.md: For any task involving **deploy**, **ship**, **release**, **migration**, **schema change**, **supabase**, **edge function**, **timestamp** / **timezone** / **date**, **failing test**, **debug**, **investigate**, or **refactor**, run recall FIRST and present the results before acting:
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/recall.py "<one-line description of what you're about to do>"
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/show.py
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/learn.py "<the rule, phrased as a principle>" \
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/memory_reflect.py \
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/memory_reflect.py \
  • adapters/claude-code/CLAUDE.md: python3 .agent/tools/memory_reflect.py \
  • adapters/claude-code/CLAUDE.md: | Value | When | |---|---| | 9–10 | Production incident, data migration, rollback, security issue | | 7–8 | Deploy, schema change, architectural decision, non-obvious constraint | | 5–6 | Refactor, significant bug fix, API contract change | | 3–4 | Routine edit, file creation, test run |
  • adapters/codex/AGENTS.md: The install script symlinks or syncs `.agents/skills` from `.agent/skills` so the portable brain remains the one source of truth.
  • adapters/codex/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/codex/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/codex/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/codex/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/codex/AGENTS.md: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/copilot-cli/AGENTS.md: re-running `./install.sh copilot-cli` will sync it back.
  • adapters/copilot-cli/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/copilot-cli/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/copilot-cli/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/copilot-cli/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/copilot-cli/AGENTS.md: Teach a rule: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/hermes/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/hermes/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/hermes/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/hermes/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/hermes/AGENTS.md: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/openclaw/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/openclaw/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/openclaw/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/openclaw/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/openclaw/AGENTS.md: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/opencode/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/opencode/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/opencode/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/opencode/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/opencode/AGENTS.md: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/pi/AGENTS.md: The install script symlinks `.pi/skills` → `.agent/skills` so every skill under the portable brain is visible to pi without duplication.
  • adapters/pi/AGENTS.md: For deploy / ship / migration / schema / timestamp / date / failing test / debug / refactor, FIRST run:
  • adapters/pi/AGENTS.md: python3 .agent/tools/recall.py "<description>"
  • adapters/pi/AGENTS.md: After significant actions, run `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/pi/AGENTS.md: Quick state: `python3 .agent/tools/show.py`.
  • adapters/pi/AGENTS.md: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • adapters/windsurf/.windsurfrules: For deploy / ship / release / migration / schema / timestamp / timezone / date / failing test / debug / investigate / refactor, run recall FIRST:
  • adapters/windsurf/.windsurfrules: python3 .agent/tools/recall.py "<short description>"
  • adapters/windsurf/.windsurfrules: After significant actions, call `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
  • adapters/windsurf/.windsurfrules: Quick state: `python3 .agent/tools/show.py`.
  • adapters/windsurf/.windsurfrules: Teach a rule in one shot: `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
  • docs/agent-install/SKILL.md: Install the CLI (macOS/Linux):
  • docs/agent-install/SKILL.md: Windows PowerShell: `git clone https://github.com/codejunkie99/agentic-stack && .\agentic-stack\install.ps1 <harness>`. · uses the network
  • docs/agent-install/SKILL.md: From the project root, run `agentic-stack <harness>` (for example `agentic-stack claude-code`).
  • docs/agent-install/SKILL.md: Verify: `agentic-stack doctor .` must report no errors, and `python3 .agent/tools/show.py --plain` must print the brain dashboard.
  • docs/agent-install/SKILL.md: Run `agentic-stack upgrade .` to refresh infrastructure without touching memory or skills.

Install scripts (3)

  • harness_manager/install.py: python harness_manager/install.py
  • install.ps1: pwsh install.ps1
  • install.sh: sh install.sh
  • Medium risk: runs-instruction-instruction-network (.agent/skills/evolver/SKILL.md:48)
  • Medium risk: runs-instruction-instruction-network (docs/agent-install/SKILL.md:18)
  • Low risk: scripts-present (.agent/memory/memory_search.py)
  • Low risk: scripts-present (.agent/skills/tldraw/store.py)
  • Low risk: scripts-present (.agent/tools/brain_bridge.py)
  • Low risk: scripts-present (.agent/tools/data_flywheel_export.py)
  • Low risk: scripts-present (.agent/tools/data_layer_export.py)
  • Low risk: scripts-present (.agent/tools/learn.py)
  • Low risk: scripts-present (.agent/tools/memory_reflect.py)
  • Low risk: scripts-present (.agent/tools/recall.py)
  • Low risk: scripts-present (.agent/tools/show.py)
  • Low risk: scripts-present (harness_manager/__init__.py)
  • Low risk: scripts-present (harness_manager/install.py)
  • Low risk: scripts-present (install.ps1)
  • Low risk: scripts-present (install.sh)

Attribution and licence

First committed by
GitHub avatar of codejunkie99codejunkie99
Publisher
Avidlive (Community)
Source
codejunkie99/agentic-stack · commit 11a75e1
Licence
Apache License 2.0 (files served here)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
ftrtyfytfjh, codejunkie99, diazMelgarejo, mv-fs, danielfoch

AutoGineer is not affiliated with or endorsed by codejunkie99.

Install from source

287 of its files are not served here, so there is no ZIP. codejunkie99/agentic-stack at 11a75e1