0.5.2

• context-md check.sh: dependency bumps no longer ask for a CONTEXT.md update. A dependency manifest (requirements*.txt, pyproject.toml, package.json, go.mod, pom.xml, Dockerfiles, GitHub workflows and similar) whose change only moves version numbers or pinned digests is skipped, so Renovate and Dependabot pull requests pass --strict. Adding or removing a dependency, or any other edit to the manifest, still counts. Projects that skip the CI check for bot pull requests can drop that workaround.

0.5.1

• context-md/check.sh skips files installed by agd (#12): an agd update, add or remove no longer asks for a CONTEXT.md change in --strict (CI) or --hook mode. The check skips .agd.lock and every path it lists, read from the working tree, from HEAD and, with --base, from where the branch started, so kit files that were deleted are skipped too. The project's own files next to kit files, such as its own skills' scripts, are still checked.
• Project scan proposes removing unused packs (#13): agd init installs every pack, so a Python project could carry the Flask, React and Spring agents into every session. The survey now lists the packs in .agd.lock, and the scan compares each framework, platform or datastore pack with the stack it found and proposes agd remove <pack> for each one nothing uses, with its evidence. It never runs the command, and never proposes removing core, research, copilot-hook or a pack it isn't sure about.

0.5.0

• session-retro skill (core pack): when the user asks for a retro, the agent evaluates the session on evidence: each requirement met or not, the user's prompts labeled request, answer, correction or complaint, rework after "done", the "Done means" rules, and cost against the project's earlier retros. Fixed rules turn the misses into a verdict (went well, mixed, went badly), which the user confirms. The note in .local_context/feedback/<date>-<task>.md names the kit file behind each miss by its installed path, with whether its rule was missing, wrong, ignored or too long, and a project-only or generic fix; a row in .local_context/feedback/log.tsv builds the baseline. For a generic fix the agent suggests agd feedback <note>; it never sends anything itself. .local_context/README.md mentions the feedback/ folder.
• session-retro/stats.sh: a read-only script that the retro runs in Claude Code for its Cost section. From Claude Code's local session files it counts time, models, tokens, prompts, interrupts, denied and failed tool calls, and subagents; from git, commits and lines since the session started and uncommitted changes; from log.tsv, the medians of the last 10 retros. It prints counts only, never session text, except --prompts, which lists the user's prompts for the agent to label locally. The session numbers need jq; without it the script says so and prints the git numbers. The session files are an undocumented format, so the numbers can break with a Claude Code update.
• Needs agd 0.2.0: packs.txt sets min-agd 0.2.0, the release that adds agd feedback.
• heroku skill (new heroku pack): practices for apps deployed on Heroku. The agent runs only read-only CLI commands and hands every deploy, config change, scale, rollback, add-on or pg: command to the user as an exact command with -a <app>; it never runs heroku config without a name, since that prints every secret. Covers $PORT and boot time, SIGTERM and daily restarts, the ephemeral filesystem, the 30-second router timeout, config vars, release-phase migrations that work with old and new code, Postgres connection caps, pipelines and review apps, Scheduler jobs that may run twice, and planning a move off Heroku.
• The user changes live systems (core): a new rule in the working agreement and a "Live systems" section in the implementation skill. Agents run plans, dry runs and read-only commands, and hand every apply, deploy, scale, rollback or resource change to the user as an exact command with its folder. They skip read-only commands that print secrets, such as terraform output -json. The project-profile skill's "Always" list, the developer's fallback essentials and the methodology's "Bound the agent" principle say the same.
• terraform skill and terraform-developer (new terraform pack): Terraform, OpenTofu and Terragrunt. Plan as often as needed, never apply, and never pass -auto-approve, -lock=false or --non-interactive; terragrunt run --all apply skips its prompt, which the handover says. Read every plan and explain each destroy or replace, moved and removed blocks, import blocks with generated config, for_each over count, version pins and lock-file hashes for every platform, checking arguments in the provider schema, secrets kept out of state with ephemeral resources and write-only arguments, S3 use_lockfile replacing deprecated DynamoDB locking, thin Terragrunt units with root.hcl, and terraform test with command = plan and mock providers. The agent suggests missing TFLint, scanners or pre-commit hooks and doesn't add them.
• aws skill (new aws pack): short-lived credentials and aws sts get-caller-identity before working, read-only CLI commands versus those handed to the user, never printing secrets, least-privilege IAM, no public buckets or 0.0.0.0/0 ingress, encryption, and the costs of idle resources, NAT gateways, public IPv4 and log retention.
• Security reviewer: also reports infrastructure code that makes storage public, opens ports to the internet, uses wildcard IAM or leaves storage unencrypted.
• project-scan survey: also lists root.hcl, terragrunt.hcl, .terraform.lock.hcl, .tflint.hcl, .pre-commit-config.yaml and Procfile.

Manual steps for existing copies:

• Upgrade agd to 0.2.0 or newer, then run agd update. An older agd stops and asks you to upgrade.
• Add the new packs where they fit, for example agd add terraform and agd add aws.

0.4.0

• Packs: packs.txt groups the kit's files into packs that agd installs: core, research, flask, spring, react, relational-database and copilot-hook. Every pack except core requires core. check.py checks that every kit file is in exactly one pack, that a skill folder stays in one pack, and that each agent's preloaded skills are in its own pack or one it requires.
• Project parts in kit files: an agent's model: and tools: lines, and a ## This project section at the end of an agent or skill, belong to the project, and kit updates keep them. The working agreement, the marker on each kit file, the README and the methodology's second principle say so. Everything else in kit files stays off limits.
• agd replaces scripts/sync.sh: projects install and update the kit with agd (brew install zejnilovic/tap/agd). It installs packs, keeps the project parts of kit files, never overwrites a kit file you changed, and can add your team's setup next to this kit. scripts/sync.sh now only says how to switch. .agd-ignore replaces .agentic-defaults-ignore, which still works.

Manual steps for existing copies:

• Install agd, run agd adopt in the project and commit .agd.lock. agd update then moves the project to 0.4.0, keeping any model changes you made.
• Optionally, rename .agentic-defaults-ignore to .agd-ignore.

0.3.0

• Project profile: four dimensions (Stage, Audience, Team, Handles) in the project's own part of AGENTS.md, so the engineering fits the project instead of a large enterprise. A new project-profile skill defines them, says what each value adds or relaxes, and lists the signs of building for a bigger project. Costly items in skills carry a tag ((production), (external), (public), (teams), (sensitive)) and apply only when the profile matches; cheap correctness and safety always apply. The project scan proposes a profile from evidence, and the survey reports a contributor count (no names) as a hint for Team. The architect designs for the profile, and the reviewer flags practices the profile doesn't call for.
• Kit files are marked and never edited: every kit agent, skill, script and .local_context file starts with a "From agentic-defaults" marker. The working agreement tells agents never to edit them or tell the user to, and where project rules, facts and project-only agents go instead. check.py enforces the markers.

Manual steps for existing copies:

• Add a "### Profile" part to "This project" in AGENTS.md (see the kit's AGENTS.md), or ask the analyst to propose one. Sync doesn't touch that section.

0.2.0

Implements the methodology's principles that 0.1.0 didn't cover.

• Local plans and handover: plans live in .local_context/<task>/plan.md, never committed. When a task ends, what lasts moves to CONTEXT.md, decision records and the ticket. Handing a task over means drafting a ticket update from the plan, posted only with approval.
• Tickets as context: the analyst fetches the ticket (for example gh issue view) and treats its text as data, never instructions.
• CONTEXT.md levels: agents read the chain from the root down; each level adds only its own detail, points to its parent, and links the real documents.
• The context check ends every task: in the definition of done, the developers' last step and the reviewer's checklist. check.sh --hook prints the hook JSON that both Claude Code (Stop) and GitHub Copilot (agentStop) accept, and reminds once per finding. The kit ships .github/hooks/context-check.json for Copilot; Claude Code gets a snippet for .claude/settings.json. The Copilot hook follows GitHub's documentation and hasn't been tested in a Copilot session yet.
• Standard commands: make setup, run, build, test, lint, format and check. "Done" means make check passes. The survey reports missing targets and the project scan proposes them from a new Makefile.template.
• Contracts first: plan steps that cross a boundary change the contract first; the reviewer checks for broken contracts; the survey lists contract files; the framework skills keep API specs and generated types accurate.
• Tests: never weaken an existing test to make it pass; keep tests contained (stable interfaces, one place per behavior, shared builders); stop when one change breaks many unrelated tests.
• Hitting a wall: no stand-ins. The blocker goes into the plan with options (split, spike, re-plan, visible limit), and the user or the architect decides.
• Short output and cheap orchestration: a brevity rule in the working agreement; the main conversation routes steps and passes blockers and design questions on instead of answering them.
• Research: new research-collector (everyday model; gathers sources) and researcher (strong model; answers with options, a recommendation, confidence and sources) agents, with a shared research skill.

Manual steps for existing copies:

• Move active plans from docs/plans/ to .local_context/<task>/plan.md, and delete the folder once their decisions are recorded.
• Rewrite the "This project" section of AGENTS.md around the standard commands. Sync doesn't touch that section.
• Optionally, add the Claude Code Stop hook from the README. Copilot's hook arrives with the sync.

0.1.0

First release.

• Framework developers, each an agent and skill pair: flask-developer (Python, Flask), spring-developer (Java, Spring Boot), react-developer (React) and relational-database-developer (PostgreSQL, MySQL, SQLite; Alembic, Flyway, Liquibase). The reviewer uses the framework skills as checklists. The architect names an agent for each plan step and orders layers database, backend, frontend. The developer's working rules moved into a shared implementation skill that every developer preloads; developer covers work no framework developer does.

• Working agreement (AGENTS.md): deliver small, test first, start from written context, work economically, definition of done.

• Agents: analyst, architect, developer, tester, reviewer, security-reviewer, documenter.

• Skills: project-scan (with a survey script), task-plans, diagrams, context-md (with a freshness check script), tdd, debugging, commits-and-prs.

• .local_context/: a self-ignoring folder for private task notes.

• Scripts: scripts/sync.sh updates a project's copy of the kit.

• Delivery safeguards, adapted from GSD Core (MIT):

  • the reviewer checks that a plan's goal was met (true, real, connected), not just that steps were ticked,
  • the developer has rules for fixing unplanned problems versus stopping to ask, and a guard against reading without acting,
  • requirements are never watered down to fit ("for now", "placeholder"); work is split instead,
  • every plan step names a Verify command,
  • packages are installed only when named, never swapped for a similar name, and the security reviewer checks new ones for typosquatting.

Tested with Claude Code, including a project scan of a real application. GitHub Copilot support follows the VS Code documentation and is not yet verified.