chore: AI-enable with agent-memory v4.38.0 — shared memory layer + contributor/consumer fork

Mode A fresh enable: committed memory/ layer (instructions, continuity with
seeded invariants from README Scope, DRAFT vision, decay policy, smoke test,
first session log), vendor bootstraps, built-in skills, hook dispatchers with
secret guard + ritual capture, advisory CI floor. Root AGENTS.md forks
contributors (memory protocol) from package consumers (README.md), per the
two-audience model.

Co-Authored-By: Claude Code <noreply@anthropic.com>

Author: acn-ericlaw

.agent/schema.md

@@ -0,0 +1,15 @@
+# agent-memory — secret-scan exemptions (v4.34.0). Committed and human-audited.
+#
+# The pre-commit secret guard and the CI floor's changed-config scan check staged/changed
+# .json / .yml / .yaml / .properties / .toml / .ini / .env* files for [secret-material].
+# Formats that carry comments (YAML, TOML, INI, markdown) waive a deliberately-quoted example
+# by tagging the LINE with `lint:allow-secret-material`. JSON has no comments and a
+# .properties same-line comment corrupts the value — exempt such files HERE instead.
+#
+# One shell-glob pattern per line; `#` starts a comment. Applies to CONFIG files only —
+# memory/ is never exempt. Every entry is a human decision: prefer fixing the file (move the
+# value to an env var / placeholder) over exempting it, and never exempt a live credential.
+#
+# Examples:
+#   test/fixtures/postman-collection.json
+#   **/test/resources/dummy-creds.properties

.agent/secret-scan-ignore

@@ -0,0 +1,10 @@
+# agent-memory install manifest
+
+> Records which version of the agent-memory tool this repo is on, so `ENABLE.md`
+> Mode B can detect drift and upgrade in place (see the tool's `UPGRADE.md`).
+> `version` gates the upgrade ladder — don't hand-edit it unless you mean to.
+
+- **version:**       4.38.0
+- **enabled_with:**  4.38.0
+- **last_upgraded:** 2026-08-22
+- **mode:**          A

.agent/version.md

@@ -0,0 +1,5 @@
+This project uses the agent-memory shared memory system.
+
+Follow memory/PROTOCOL.md first. AGENTS.md is its one-line universal discovery shim.
+
+Identify yourself as Cursor in all session logs.

.cursorrules

@@ -0,0 +1,6 @@
+# agent-memory — keep executable scripts + git hooks LF so bash runs them on Windows (Git Bash / WSL).
+# Git for Windows defaults to core.autocrlf=true; without this, *.sh and .githooks/* would be rewritten
+# to CRLF on checkout and bash would fail with "bad interpreter: /usr/bin/env bash^M".
+*.sh        text eol=lf
+.githooks/* text eol=lf
+.githooks/*.d/* text eol=lf

.gitattributes

@@ -0,0 +1,97 @@
+# `.githooks/` — composable, vendor-neutral ritual triggers
+
+These are **committed, vendor-neutral git hook dispatchers and fragments** that reinforce the
+after-session ritual for *any* agent (Claude, Copilot, Kiro, …) — because everyone commits,
+regardless of which AI did the work. They are **advisory by default** — the pre-commit secret guard
+alone **enforces** (findings block the
+commit; a deliberate, scoped exception, because secrets carry irreversible after-the-fact cost) —
+and the **tool runs nothing itself**: git invokes them in your env at your
+opt-in (`no-build-step-agent-run`). See `docs/optional-ritual-hook.md` and `DECAY.md` for the rationale.
+
+## First-run init (one command)
+
+A fresh clone has the gitignored skill **adapters absent** and the dispatchers **unactivated** (git can't
+auto-run committed hooks on clone — security). Set both up with one idempotent command:
+
+```sh
+bash .githooks/init.sh
+```
+
+It regenerates the vendor skill adapters **and** runs `git config core.hooksPath .githooks`. **The agent
+runs this itself on a first session** (see `memory/PROTOCOL.md`), so an untrained user does nothing. To
+activate the dispatchers alone: `git config core.hooksPath .githooks` (undo:
+`git config --unset core.hooksPath`).
+**CI is the zero-config floor** — `.github/workflows/agent-memory.yml` on GitHub; `.gitlab-ci.yml` +
+`.gitlab/agent-memory-ci.yml` on GitLab (v4.31.0); `.azuredevops/agent-memory-ci.yml` on Azure
+DevOps (v4.32.0) — it runs server-side on every push and, on GitHub/GitLab, every pull/merge
+request (Azure DevOps PR-time runs need the optional Build Validation policy), so the ritual is
+enforced even on a clone where the local hook was never activated. (Honest limits: a self-managed GitLab instance needs an admin-registered runner;
+an Azure DevOps pipeline is inert until its one-time `az pipelines create` binding.)
+
+## Dispatcher contract
+
+The `pre-commit` and `post-commit` entrypoints are deliberately small dispatchers. Each runs the
+executable regular files in its matching directory — `.githooks/pre-commit.d/` or
+`.githooks/post-commit.d/` — in deterministic C-locale filename order. Hidden and non-executable
+files are ignored. Hook arguments are forwarded unchanged.
+
+Every fragment runs even when an earlier fragment fails, so independent hook layers all get a
+chance to report. The dispatcher returns the **first non-zero status** after the run. That blocks a
+pre-commit when any enforcing fragment fails; Git ignores post-commit status, while direct invocation
+and tests can still observe failures.
+
+Agent-memory's managed fragments use the `50-` slot:
+
+- `pre-commit.d/50-agent-memory-secret-guard`
+- `post-commit.d/50-agent-memory-ritual-capture`
+
+Add another executable fragment instead of replacing either hook entrypoint: use `00-`–`49-` to run
+before agent-memory or `51-`–`99-` to run after it. Upgrades refresh unchanged copies of the two
+dispatchers and managed `50-` fragments, preserve every differently named fragment, and human-gate
+any locally modified managed file instead of silently overwriting it. This gives other hook layers
+a stable composition seam and makes each behavior independently runnable in CI.
+
+The dispatcher contract itself is covered by `tests/test_githook_dispatchers.sh` in the tool repo.
+
+## Managed fragments
+
+- **`pre-commit.d/50-agent-memory-secret-guard`** (v4.34.0) — the **`[secret-material]` guard**:
+  before the commit exists, scans the
+  **staged content** (the index, not the worktree — exactly what this commit would publish; a
+  pre-existing finding elsewhere never gates an unrelated commit) of **two surfaces**:
+  `memory/**.md` (the full profile — credentials + PII) and **config files** — `.json` / `.yml` /
+  `.yaml` / `.properties` / `.toml` / `.ini` / `.env*` anywhere in the repo, credential-class checks
+  only (token shapes, key assignments, Authorization headers, private keys; config files
+  legitimately carry contact emails and paths). The config surface exists because of a real
+  incident: live credentials entered a repo inside a Postman JSON and an OpenShift YAML, then
+  contaminated a session log downstream. Findings print with the linter's non-echoing report plus
+  redaction/waiver/rotation guidance. **Enforcing by default** — findings **block the commit**
+  (secrets are the one category with irreversible after-the-fact cost); opt down to warn-only with
+  `AGENT_MEMORY_SECRET_GUARD=advisory` (env, or `git config agent-memory.secretguard advisory`);
+  one-off bypass: `git commit --no-verify`.
+  Waivers: tag the line `lint:allow-secret-material` where the format has comments (markdown,
+  YAML, TOML, INI); JSON has no comments and a `.properties` same-line comment corrupts the value —
+  list those files in the committed, human-audited **`.agent/secret-scan-ignore`** (shell-glob per
+  line; exempts config files only, never `memory/`). Runs on python3 or node, whichever exists —
+  with neither, it skips with a note. Why it exists: the ritual rule covers agents at write time
+  and the CI floor covers pushes, but by push time the remote already has the secret and redaction
+  is not un-leaking (rotation is) — this is the **one placement that prevents instead of detects**
+  (see the `memory/PROTOCOL.md` redaction rule).
+
+- **`post-commit.d/50-agent-memory-ritual-capture`** — after a commit: re-syncs skill adapters if a
+  skill changed; and if the commit did
+  real work but carried no session log, ensures the session is captured — **once per working session, not
+  per commit.** If there is **no** session log within the active-session window (default **30 min**; override
+  `AGENT_MEMORY_SESSION_WINDOW_MINUTES`) it **auto-stubs** `memory/sessions/<ts>.md`; if a recent log already
+  covers this session — committed *or* a waiting stub, detected by the newest session **filename** (immutable
+  and clone-safe, unlike mtime) — it instead **nudges you to enrich that existing log**. The stub guarantees
+  the ledger never has a silent gap; the *thoughtful* summary stays the agent's job (capture vs. judgment —
+  same split as `memory-lint`).
+
+  > **Splitting code and memory into two commits?** The advisory may fire on the code-only commit (it
+  > carries no session log) and point you at the session's existing log — **expected and benign**, not a
+  > failure, and it will **not** pile up a second stub (one log per session). To skip the nudge entirely,
+  > prefer a **single atomic commit** that includes the work *and* its session log. The hook is advisory
+  > and never blocks.
+
+To deactivate: `git config --unset core.hooksPath`.

.githooks/README.md

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# agent-memory — first-run init. Run ONCE after a fresh clone (or any time setup looks off).
+# Idempotent + advisory. Closes the fresh-clone gap: a clone has the gitignored skill adapters
+# ABSENT and the git hook dispatchers UNACTIVATED (git can't auto-run committed hooks on clone — security).
+# This single command sets both up. The agent runs it itself on a first session (see memory/PROTOCOL.md);
+# this is the human one-command fallback. On GitHub / GitLab.com, CI runs server-side regardless,
+# with or without this (a self-managed GitLab needs an admin-registered runner; an Azure DevOps
+# pipeline runs once its one-time activation is done).
+set -e
+cd "$(git rev-parse --show-toplevel 2>/dev/null || echo .)"
+
+echo "agent-memory init: (1/2) regenerating skill adapters…"
+if [ -f agent-skills/sync-adapters/scripts/sync-adapters.sh ]; then
+  bash    agent-skills/sync-adapters/scripts/sync-adapters.sh \
+    || node    agent-skills/sync-adapters/scripts/sync-adapters.mjs \
+    || python3 agent-skills/sync-adapters/scripts/sync-adapters.py \
+    || echo "  (no bash/node/python runtime for sync-adapters; skipped — adapters can be synced later)"
+else
+  echo "  (no sync-adapters skill present; skipped)"
+fi
+
+echo "agent-memory init: (2/2) activating the git hook dispatchers (pre-commit secret guard + post-commit ritual capture fragments)…"
+if [ -d .githooks ]; then
+  git config core.hooksPath .githooks
+  echo "  core.hooksPath = $(git config core.hooksPath)"
+fi
+
+echo "agent-memory init: done — adapters synced + git hook dispatchers active. (On GitHub / GitLab.com, CI runs server-side regardless.)"

.githooks/init.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+# post-commit fragment dispatcher. Executable files in post-commit.d run in C-locale
+# filename order. Every fragment runs; the first non-zero status is returned (Git ignores
+# post-commit status, but direct invocation and tests can still observe it).
+# Bash 3.2-compatible.
+
+LC_COLLATE=C
+
+hook_dir="$(CDPATH= cd "$(dirname "$0")" 2>/dev/null && pwd)" || exit 1
+fragment_dir="$hook_dir/post-commit.d"
+[ -d "$fragment_dir" ] || exit 0
+
+status=0
+for fragment in "$fragment_dir"/*; do
+  [ -f "$fragment" ] || continue
+  [ -x "$fragment" ] || continue
+
+  "$fragment" "$@"
+  fragment_status=$?
+  if [ "$fragment_status" -ne 0 ]; then
+    [ "$status" -ne 0 ] || status="$fragment_status"
+    printf 'post-commit: fragment %s failed with status %s\n' \
+      "${fragment##*/}" "$fragment_status" >&2
+  fi
+done
+
+exit "$status"

.githooks/post-commit

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# agent-memory post-commit fragment — vendor-neutral, advisory ritual reinforcement.
+# (Introduced v4.19.0; auto-stub made per-session in v4.22.1, window retuned to 30 min in v4.22.3.)
+#
+# Activated by `git config core.hooksPath .githooks` (the agent runs this at enable — no manual
+# user step). Fires after every commit; NEVER blocks (post-commit exit codes are ignored by git).
+# The tool runs nothing itself — git invokes this in the user's env at their opt-in
+# (`no-build-step-agent-run`). Bash 3.2-compatible.
+#
+# What it does, only in an agent-memory repo:
+#   1) keep skill adapters current when a skill changed (idempotent, gitignored-only);
+#   2) if the commit did real work but no session log exists within the active-session window
+#      (default 30 min; override AGENT_MEMORY_SESSION_WINDOW_MINUTES), auto-stub one; if a recent
+#      log already covers this session, nudge to enrich it instead — at most ONE stub per session,
+#      not per commit. Capture only; the thoughtful summary stays the agent's job (no silent gap).
+
+[ -f memory/continuity.md ] || exit 0          # only act in an agent-memory repo
+git rev-parse -q --verify HEAD^2 >/dev/null 2>&1 && exit 0   # skip merge commits
+
+changed="$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null)"
+
+# (1) re-sync adapters if a skill changed in this commit
+if printf '%s\n' "$changed" | grep -qE '^agent-skills/'; then
+  bash   agent-skills/sync-adapters/scripts/sync-adapters.sh  >/dev/null 2>&1 \
+    || node   agent-skills/sync-adapters/scripts/sync-adapters.mjs >/dev/null 2>&1 \
+    || python3 agent-skills/sync-adapters/scripts/sync-adapters.py  >/dev/null 2>&1 || true
+fi
+
+# (2) auto-stub the session log if real work landed without one
+work="$(printf '%s\n' "$changed" | grep -vE '^(memory/|\.agent/)' | grep -v '^$' || true)"
+logged="$(printf '%s\n' "$changed" | grep -E '^memory/sessions/.*\.md$' || true)"
+
+if [ -n "$work" ] && [ -z "$logged" ]; then
+  # A "session" is a *burst of work within a window*, not a single commit. A session log added
+  # earlier in this same session — whether already committed OR still an untracked stub — must
+  # suppress a NEW stub, or a multi-commit session piles up one near-identical stub per commit
+  # (and inflates the decay session-count). Detect it by the newest session-log FILENAME
+  # timestamp: it is immutable and clone-safe (unlike mtime, which `git clone`/checkout resets
+  # to now — that would wrongly suppress the first stub for hours after every clone). Compare,
+  # lexicographically, against a "window-ago" stamp in the same YYYY-MM-DD-HHMMSS form (which
+  # sorts chronologically). Window default 30 min — long enough to span a working session's commit
+  # cadence (incl. a short test/think gap), short enough that a genuinely NEW session (a longer pause)
+  # still gets its own stub. Override with AGENT_MEMORY_SESSION_WINDOW_MINUTES (integer minutes).
+  # Primary guard: if a session log is already uncommitted (staged, modified, or untracked),
+  # the agent has an in-flight log for this session — skip the stub regardless of its age.
+  # This handles the recommended two-commit pattern (feature commit → chore(memory) commit) where
+  # the log is written but not yet committed, and long sessions where the write→commit gap exceeds
+  # the time window.
+  if git status --porcelain -- memory/sessions/ 2>/dev/null | grep -qE '\.md$'; then
+    echo "agent-memory: this commit changed tracked files but added no session log; an uncommitted" >&2
+    echo "              session log already covers this session — enrich/commit it (one log per" >&2
+    echo "              session, not per commit)." >&2
+    exit 0
+  fi
+
+  win="${AGENT_MEMORY_SESSION_WINDOW_MINUTES:-30}"
+  newest="$(ls memory/sessions/ 2>/dev/null | grep -E '^[0-9]{4}-[0-9]{2}-[0-9]{2}-[0-9]{6}\.md$' | sort | tail -n1)"
+  newest="${newest%.md}"
+  threshold="$(date -u -v-"${win}"M +%Y-%m-%d-%H%M%S 2>/dev/null \
+            || date -u -d "${win} minutes ago" +%Y-%m-%d-%H%M%S 2>/dev/null || true)"
+
+  if [ -n "$newest" ] && [ -n "$threshold" ] && [[ "$newest" > "$threshold" ]]; then
+    # a session log already exists for the current working session — don't pile on another stub
+    echo "agent-memory: this commit changed tracked files but added no session log; a recent one" >&2
+    echo "              (memory/sessions/$newest.md, within ${win} min) covers this session — enrich/update" >&2
+    echo "              it if this commit added something noteworthy (one log per session, not per commit)." >&2
+  else
+    # genuinely new session (no session log within the window) — stub one so the ledger never gaps
+    ts="$(date -u +%Y-%m-%d-%H%M%S)"
+    stub="memory/sessions/$ts.md"
+    {
+      printf '# Session (%s)\n\n' "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)"
+      printf '**Agent:** (auto-stub — replace with your agent name and enrich)\n'
+      printf '**Lightweight:** auto-captured by the post-commit hook; summary pending.\n\n'
+      printf 'Commit `%s` — %s\n\n' "$(git rev-parse --short HEAD)" "$(git log -1 --pretty=%s)"
+      printf '```\n%s\n```\n\n' "$(git diff-tree --no-commit-id --stat -r HEAD 2>/dev/null)"
+      printf '## Memory References\n'
+      printf '(none — auto-stub; enrich per memory/PROTOCOL.md "Close every session", or leave as a lite log)\n'
+    } > "$stub"
+    echo "agent-memory: auto-stubbed a session log → $stub" >&2
+    echo "              enrich it (or keep it as a lite log) and commit it, per memory/PROTOCOL.md." >&2
+  fi
+fi
+exit 0

.githooks/post-commit.d/50-agent-memory-ritual-capture

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# pre-commit fragment dispatcher. Executable files in pre-commit.d run in C-locale
+# filename order. Every fragment runs; the first non-zero status is returned.
+# Bash 3.2-compatible.
+
+LC_COLLATE=C
+
+hook_dir="$(CDPATH= cd "$(dirname "$0")" 2>/dev/null && pwd)" || exit 1
+fragment_dir="$hook_dir/pre-commit.d"
+[ -d "$fragment_dir" ] || exit 0
+
+status=0
+for fragment in "$fragment_dir"/*; do
+  [ -f "$fragment" ] || continue
+  [ -x "$fragment" ] || continue
+
+  "$fragment" "$@"
+  fragment_status=$?
+  if [ "$fragment_status" -ne 0 ]; then
+    [ "$status" -ne 0 ] || status="$fragment_status"
+    printf 'pre-commit: fragment %s failed with status %s\n' \
+      "${fragment##*/}" "$fragment_status" >&2
+  fi
+done
+
+exit "$status"