agent-memory-cli 0.1.0__py3-none-any.whl

agent_memory/templates/project-memory/known_debt.md

@@ -0,0 +1,8 @@
+# Known Debt
+
+Use this file to track verified, unresolved project debt that future sessions
+should not rediscover from scratch.
+
+| Item | Severity | Date Found | Source | Status |
+| --- | --- | --- | --- | --- |
+| _None yet._ |  |  |  |  |

agent_memory/templates/project-memory/open_threads.md

@@ -0,0 +1,3 @@
+# Open Threads
+
+- None yet.

agent_memory/templates/project-memory/project_facts.md

@@ -0,0 +1,4 @@
+# Project Facts
+
+<!-- Stable facts about this project: what it is, where it runs, who owns what. -->
+<!-- Rewrite in place as facts change; the history of a change belongs in decision_log.md. -->

agent_memory/templates/workflow/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: agent-memory
+description: Cross-session memory for this repository. Use at session start to read the bounded memory context (recall), and whenever a decision is made that a later session must not rediscover (capture). Also use when asked what was decided before.
+---
+
+# agent-memory workflow for {runtime}
+
+Managed by `agent-memory setup {runtime}`: a rerun regenerates this file only
+while its digest matches a shipped template; an edited file is reported as a
+conflict and kept. The rules are the same for every runtime; only the agent
+name differs.
+
+## Recall, at session start
+
+The session-start hook printed the startup manifest: the memory files to read,
+in order, with their readability only. No content was injected. Before acting
+on project work, read the bounded context in one step:
+
+    agent-memory recall
+
+It prints the project's active files (`project_facts.md`, `decision_log.md`,
+`open_threads.md`, `known_debt.md`), then the curated org files (`recent.md`,
+`decisions.md`, `rules.md`), cut at a character budget (`--max-chars`, default
+8000). Cite a decision by its date heading and its text. `archive/`, `events/`
+and `debriefs/` are never loaded; read them only when the work needs them.
+
+## Capture, when a decision is made
+
+When the user decides something that a future session must not rediscover,
+record it once, in one sentence, with the reason:
+
+    agent-memory capture --agent {runtime} "<the decision>" --why "<the reason>" --source "<PR, issue or message>"
+
+It appends a dated entry, newest first, to the project's `decision_log.md`,
+with provenance: the agent, the UTC time and the source. Capture only what the
+user decided, not what you propose; confirm first when in doubt. One decision
+per entry. Stable facts go to `project_facts.md` by hand, not through capture.
+
+## Out of scope
+
+No synthesis, search or index; no writes to the org tier; no push. Syncing the
+home is `agent-memory push`, run deliberately, never from this workflow.

agent_memory/workflow.py

@@ -0,0 +1,287 @@
+# SPDX-FileCopyrightText: 2026 Kiloloop
+# SPDX-License-Identifier: Apache-2.0
+"""The minimal memory workflow: ``agent-memory capture`` and ``agent-memory recall``.
+
+Two verbs and one authored text. ``capture`` appends one decision, with its
+provenance, to the project's ``decision_log.md``, newest first under a UTC
+date heading; it never writes through a symlink (a linked component anywhere
+below the home, the file included, is refused, never followed), replaces the
+file atomically with the file's own mode, and touches no other file. ``recall`` prints the content of the files the
+startup manifest lists, in the manifest's order, cut at a character budget
+with a notice: the bounded read the manifest describes but never performs.
+``archive/``, ``events/`` and ``debriefs/`` are never loaded.
+
+The authored text is the workflow file ``setup <runtime>`` installs beside the
+hook, rendered from one shipped template with the runtime's name; every
+runtime's wrapper says the same thing.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import os
+import re
+import secrets
+import stat as stat_mod
+from importlib import resources
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from . import layout, startup
+
+SCHEMA_VERSION = 1
+DECISION_FILE = "decision_log.md"
+DEFAULT_AGENT_ENV = "AGENT_MEMORY_AGENT"
+WORKFLOW_TEMPLATE = "templates/workflow/SKILL.md"
+
+_HEADING = re.compile(r"^## (\d{4}-\d{2}-\d{2})\s*$")
+_SPACE = re.compile(r"\s+")
+
+
+class WorkflowError(Exception):
+    """A precondition failed; nothing was written."""
+
+
+# --- the authored text ---------------------------------------------------------
+
+
+def workflow_text(runtime: str) -> str:
+    """The workflow file for ``runtime``, byte for byte what setup writes."""
+    template = (resources.files(__package__) / WORKFLOW_TEMPLATE).read_text(encoding="utf-8")
+    return template.replace("{runtime}", runtime)
+
+
+# --- capture -------------------------------------------------------------------
+
+
+def default_agent() -> str:
+    """Who is capturing: ``$AGENT_MEMORY_AGENT`` (the hook exports it), else the user, else ``unknown``."""
+    return os.environ.get(DEFAULT_AGENT_ENV) or os.environ.get("USER") or "unknown"
+
+
+def default_runtime() -> str:
+    """The runtime reading: ``$AGENT_MEMORY_AGENT`` when it names one, else claude."""
+    agent = os.environ.get(DEFAULT_AGENT_ENV)
+    return agent if agent in startup.RUNTIMES else startup.RUNTIME_CLAUDE
+
+
+def format_entry(decision: str, *, why: Optional[str], agent: str, source: Optional[str], now: dt.datetime) -> str:
+    """One decision as a list line: the decision, its reason, then the provenance in parentheses."""
+    text = _one_line(decision)
+    if not text:
+        raise WorkflowError("the decision is empty")
+    parts = [f"- **{text}**"]
+    reason = _one_line(why or "")
+    if reason:
+        parts.append(f" Why: {reason}")
+    provenance = [_one_line(agent) or "unknown", _iso(now)]
+    reference = _one_line(source or "")
+    if reference:
+        provenance.append(f"source: {reference}")
+    parts.append(f" ({', '.join(provenance)})")
+    return "".join(parts)
+
+
+def capture(
+    home: Path,
+    project: str,
+    decision: str,
+    *,
+    why: Optional[str] = None,
+    source: Optional[str] = None,
+    agent: Optional[str] = None,
+    now: Optional[dt.datetime] = None,
+    dry_run: bool = False,
+) -> Dict[str, Any]:
+    """Append ``decision`` to the project's decision log, newest first under today's UTC heading."""
+    home = Path(home).expanduser().absolute()
+    layout.validate_project_name(project)
+    memory = layout.project_memory_dir(home, project)
+    path = memory / DECISION_FILE
+    moment = now or dt.datetime.now(dt.timezone.utc)
+    agent_name = agent or default_agent()
+    entry = format_entry(decision, why=why, agent=agent_name, source=source, now=moment)
+    date = _iso(moment)[:10]
+
+    link = _linked_component(home, path)
+    if link is not None:
+        raise WorkflowError(f"{link} is a symlink; the workflow never writes through a link")
+    if not memory.is_dir():
+        raise WorkflowError(
+            f"project {project!r} has no memory tier at {memory}; create it with `agent-memory init --project {project}`"
+        )
+    try:
+        info = os.lstat(path)
+    except FileNotFoundError:
+        raise WorkflowError(f"{path} is missing; recreate it with `agent-memory init --project {project}`") from None
+    except OSError as exc:
+        raise WorkflowError(f"cannot inspect {path}: {exc}") from exc
+    if not stat_mod.S_ISREG(info.st_mode):
+        raise WorkflowError(f"{path} is not a regular file")
+    try:
+        before = path.read_bytes().decode("utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        raise WorkflowError(f"cannot read {path}: {exc}") from exc
+
+    after = insert_entry(before, date, entry)
+    result = {
+        "schema_version": SCHEMA_VERSION,
+        "action": "capture",
+        "home": str(home),
+        "project": project,
+        "path": str(path),
+        "date": date,
+        "entry": entry,
+        "agent": agent_name,
+        "dry_run": dry_run,
+        "written": False,
+    }
+    if dry_run:
+        return result
+    _replace_text(path, after, mode=stat_mod.S_IMODE(info.st_mode))
+    result["written"] = True
+    return result
+
+
+def insert_entry(text: str, date: str, entry: str) -> str:
+    """``text`` with ``entry`` as the first item under the ``## date`` heading, creating the heading newest-first."""
+    lines = text.split("\n")
+    if lines and lines[-1] == "":
+        lines.pop()  # the trailing newline; restored below
+    first = next((index for index, line in enumerate(lines) if _HEADING.match(line)), None)
+    if first is not None and _HEADING.match(lines[first]).group(1) == date:
+        at = first + 1
+        if at < len(lines) and lines[at] == "":
+            at += 1
+        lines[at:at] = [entry]
+    else:
+        block = [f"## {date}", "", entry, ""]
+        if first is None:
+            if lines and lines[-1] != "":
+                lines.append("")
+            lines.extend(block[:-1])
+        else:
+            at = first
+            if at > 0 and lines[at - 1] != "":
+                block.insert(0, "")
+            lines[at:at] = block
+    return "\n".join(lines) + "\n"
+
+
+def _linked_component(home: Path, path: Path) -> Optional[Path]:
+    """The first symlink below ``home`` on the way down to ``path`` (``path`` included), or ``None``.
+
+    The home itself may be a link (a workspace marker is one); every component
+    beneath it is inspected without following, so a linked ``projects/``,
+    project or memory directory is refused before anything is read or staged.
+    A component that does not exist ends the walk: the later checks name it.
+    """
+    current = home
+    for part in path.relative_to(home).parts:
+        current = current / part
+        try:
+            info = os.lstat(current)
+        except (FileNotFoundError, NotADirectoryError):
+            return None
+        except OSError as exc:
+            raise WorkflowError(f"cannot inspect {current}: {exc}") from exc
+        if stat_mod.S_ISLNK(info.st_mode):
+            return current
+    return None
+
+
+def _replace_text(path: Path, text: str, *, mode: int) -> None:
+    """Write ``text`` beside ``path`` and move it into place atomically; the file keeps its mode."""
+    data = text.encode("utf-8")
+    temp = path.with_name(f".{path.name}.{secrets.token_hex(4)}.tmp")
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0)
+    try:
+        fd = os.open(temp, flags, mode)
+    except OSError as exc:
+        raise WorkflowError(f"cannot stage the write beside {path}: {exc}") from exc
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            os.fchmod(handle.fileno(), mode)  # os.open applied the umask; the original bits win
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp, path)
+    except OSError as exc:
+        try:
+            os.unlink(temp)
+        except OSError:
+            pass
+        raise WorkflowError(f"cannot write {path}: {exc}") from exc
+
+
+# --- recall --------------------------------------------------------------------
+
+
+def recall(
+    home: Path,
+    *,
+    project: Optional[str],
+    runtime: str = startup.RUNTIME_CLAUDE,
+    max_chars: int = startup.DEFAULT_MAX_CHARS,
+    home_source: str = "flag",
+    project_source: Optional[str] = None,
+    notes: List[str] = (),
+) -> Dict[str, Any]:
+    """The bounded read: the manifest's readable files, in its order, with their content, cut at ``max_chars``."""
+    manifest = startup.build_manifest(
+        home, runtime=runtime, project=project, home_source=home_source, project_source=project_source, notes=notes
+    )
+    parts: List[str] = []
+    files: List[Dict[str, Any]] = []
+    head = f"agent-memory recall: home {manifest['home']}"
+    head += f", project {manifest['project']}" if manifest["project"] is not None else ", no project"
+    parts.append(head + f"; content follows in manifest order, cut at {max_chars} characters.")
+    for entry in manifest["files"]:
+        row = {"tier": entry["tier"], "relative": entry["relative"], "state": entry["state"], "bytes": entry["bytes"]}
+        if entry["state"] == startup.READABLE:
+            try:
+                content = Path(entry["path"]).read_bytes().decode("utf-8", errors="replace")
+            except OSError as exc:
+                row["state"] = startup.UNREADABLE
+                row["error"] = exc.strerror or str(exc)
+                manifest["warnings"].append(f"{entry['relative']}: unreadable ({row['error']})")
+            else:
+                parts.append(f"\n--- {entry['relative']} ({entry['bytes']} bytes, modified {entry['modified_at_utc']}) ---")
+                parts.append(content.rstrip("\n"))
+        files.append(row)
+    parts.append(f"\nExcluded by default: {', '.join(manifest['excluded'])}")
+    if manifest["warnings"]:
+        parts.append("Warnings:")
+        parts.extend(f"  - {warning}" for warning in manifest["warnings"])
+    text = _bound("\n".join(parts) + "\n", max_chars)
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "action": "recall",
+        "home": manifest["home"],
+        "project": manifest["project"],
+        "content_injected": True,
+        "max_chars": max_chars,
+        "files": files,
+        "excluded": manifest["excluded"],
+        "warnings": manifest["warnings"],
+        "truncated": len(text) < len("\n".join(parts)) + 1,
+        "text": text,
+    }
+
+
+def _bound(text: str, max_chars: int) -> str:
+    max_chars = max(0, max_chars)
+    if len(text) <= max_chars:
+        return text
+    suffix = f"\n[agent-memory: recall cut at {max_chars} characters; raise --max-chars or read the remaining files directly]\n"
+    if len(suffix) >= max_chars:
+        suffix = "[cut]\n"[:max_chars]
+    return text[: max_chars - len(suffix)] + suffix
+
+
+def _one_line(text: str) -> str:
+    return _SPACE.sub(" ", text).strip()
+
+
+def _iso(moment: dt.datetime) -> str:
+    return moment.astimezone(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")

agent_memory_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,261 @@
+Metadata-Version: 2.5
+Name: agent-memory-cli
+Version: 0.1.0
+Summary: Cross-session memory for coding agents: plain files, git-native, no server
+Project-URL: Homepage, https://github.com/kiloloop/agent-memory
+Project-URL: Source, https://github.com/kiloloop/agent-memory
+Project-URL: Changelog, https://github.com/kiloloop/agent-memory/blob/main/CHANGELOG.md
+Author: Kiloloop
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: agents,git,markdown,memory
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == 'dev'
+Requires-Dist: pytest<10,>=8; extra == 'dev'
+Requires-Dist: ruff<1,>=0.11; extra == 'dev'
+Requires-Dist: twine<8,>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agent-memory
+
+Cross-session memory for coding agents — plain files, git-native, no server.
+
+## Why
+
+Agents start sessions blank. Keep facts, decisions, and unfinished work in
+Markdown you can read and edit.
+
+Memory travels **between agents** via project files, **between projects** via
+org rules, and **between machines** via optional git sync. Claude Code and Codex
+share the store. No database, daemon, server, or runtime Python dependencies.
+
+## Quick Start
+
+First time: install and bind. Every session after: recall context, capture decisions.
+
+### With your coding agent
+
+Paste this into Claude Code or Codex from your repository:
+
+```text
+Set up cross-session memory with agent-memory-cli from
+https://pypi.org/project/agent-memory-cli/ and its source,
+https://github.com/kiloloop/agent-memory.
+
+Install with Python 3.10+. Ask for my home and project name, initialize and
+bind this repository, and git-ignore the binding. Set up my runtime's hook
+and workflow; report conflicts.
+
+Capture a decision I provide, with its reason and runtime. Show status and
+doctor. Next session here, recall context and report any truncation or sync
+warning. Ask for my remote before enabling optional sync; keep pushing explicit.
+```
+
+### Manually
+
+Python 3.10+ is required; sync needs git 2.25+, hooks use Bash, and
+`archive`/`restore` are POSIX-only.
+
+1. **Install** with `uv tool install agent-memory-cli` or
+   `python -m pip install agent-memory-cli`. The distribution and the command
+   differ: installing `agent-memory-cli` gives you `agent-memory`. Put it on
+   your agent's PATH.
+2. **Bind**, from your repository root:
+
+   ```bash
+   agent-memory init --home "$HOME/agent-memory" --project my-app --repo .
+   ```
+
+   Git-ignore `.agent-memory.json`. Stay here; unset `AGENT_MEMORY_HOME`/`OACP_HOME` or point them at this
+   home: they precede the binding.
+3. **Set up** the runtime you use, then enable the hook there if required:
+
+   ```bash
+   agent-memory setup claude
+   # Or:
+   agent-memory setup codex
+   ```
+
+4. **Record now; recall next session** in this repository:
+
+   ```bash
+   agent-memory capture "Use SQLite for the cache." --why "no daemon" --agent codex
+   agent-memory recall
+   agent-memory status
+   agent-memory doctor
+   ```
+
+   Use `--agent claude` if appropriate; recall also works now for inspection.
+5. **Optionally sync.** Use an empty private remote. `enable --remote` pushes
+   the initial commit; substitute its URL:
+
+   ```bash
+   agent-memory enable --remote git@github.com:YOUR_ORG/agent-memory-store.git
+   agent-memory push --agent codex
+   # After another machine pushes, with a clean local tree:
+   agent-memory pull
+   ```
+
+   Elsewhere, `agent-memory clone <remote-url> --home <local-home>`, then repeat
+   binding and setup. Bind each machine separately; push explicitly.
+
+## How It Works
+
+![Four project memory files with sample Markdown](https://raw.githubusercontent.com/kiloloop/agent-memory/main/docs/images/project-memory.jpg)
+
+*Illustrative files; not a bundled application UI.*
+
+OACP defines the layout; this tool implements it. The four active files in
+`projects/<name>/memory/` hold notes such as these trimmed samples:
+
+| File | Purpose and sample |
+| --- | --- |
+| `project_facts.md` | Stable facts: FastAPI backend; Postgres; no PII in logs. |
+| `decision_log.md` | Choices: 2026-05-09 — retry 5xx three times, with backoff and jitter. |
+| `open_threads.md` | Work and owners: OAuth refresh race — waiting on Codex. |
+| `known_debt.md` | Problems: replace the hard-coded session TTL with a setting. |
+
+Date entries; supersede decisions by adding new ones. Close or pause threads,
+write for humans, and distill transcripts. Edit other files directly; promote
+debt to a thread when work starts.
+
+`org-memory/` sits beside `projects/`: `recent.md`, `decisions.md`, and
+`rules.md` carry shared context; `events/` and `debriefs/` hold records.
+Most notes belong to a project. Use org memory only across repositories.
+
+Home resolution: `--home` → `AGENT_MEMORY_HOME` → `OACP_HOME` → nearest ancestor
+`.agent-memory.json` → workspace marker → `~/agent-memory`. A workspace marker
+points into a home's `projects/` tree. Project selection uses `--project` or a
+matching binding/marker. OACP is not required.
+
+Sync makes the home a git repository with an allowlist and `.oacp-memory-repo`
+marker. `push` commits selected paths; `pull` fast-forwards a clean tree that
+is not ahead or diverged. No merges; keys and setup receipts stay local.
+Network verbs time out after 30 seconds.
+
+`setup` installs a SessionStart hook and memory workflow. `startup` lists
+metadata for the four project files, then the three curated org files; it
+injects no content. `--pull` refreshes first, warning on failure. The workflow
+tells the agent to run `recall` for an 8,000-character bounded read. Raise
+`--max-chars` or read remaining files directly when cut. `capture` records
+decisions during work. At the end, update threads and debt, optionally publish
+a summary with `debrief write`, and explicitly `push`; no push hook is installed.
+
+Startup and recall exclude `archive/`, `events/`, and `debriefs/`. This is not
+a vector database, RAG pipeline, or chat-history store: no embeddings,
+similarity queries, synthesis, or indexing. Recall reads a fixed file set.
+
+### Commands
+
+| Command | Purpose |
+| --- | --- |
+| [`status`][status] | Inspect home and sync. |
+| [`doctor`][doctor] | Check health; repair nothing. |
+| [`init`][init] | Scaffold and bind. |
+| [`org init`][init] | Scaffold org memory. |
+| [`enable`][sync] | Enable git sync. |
+| [`clone`][sync] | Clone a memory remote. |
+| [`pull`][sync] | Fast-forward from upstream. |
+| [`push`][sync] | Commit selected files and push. |
+| [`disable`][sync] | Disable sync. |
+| [`archive`][archive-and-restore] | Archive a supplementary file. |
+| [`restore`][archive-and-restore] | Restore to an empty slot. |
+| [`setup`][setup] | Install runtime integration. |
+| [`startup`][startup] | Print the metadata manifest. |
+| [`capture`][capture-and-recall] | Record a decision. |
+| [`recall`][capture-and-recall] | Read bounded context. |
+| [`debrief write`][debrief-write] | Publish a session summary. |
+
+[status]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#status
+[doctor]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#doctor
+[init]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#init
+[sync]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#sync
+[archive-and-restore]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#archive-and-restore
+[setup]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#setup
+[startup]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#startup
+[capture-and-recall]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#capture-and-recall
+[debrief-write]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#debrief-write
+
+## Examples
+
+Scratch run in `/private/tmp/am-readme-demo`: init/startup/recall excerpts;
+other outputs complete.
+
+```console
+$ agent-memory init --home memory --project demo
+Initialized memory home: /private/tmp/am-readme-demo/memory
+```
+
+```console
+$ agent-memory startup --home memory --project demo --runtime claude --max-chars 420
+agent-memory startup (claude): home /private/tmp/am-readme-demo/memory (flag), project demo (flag)
+Project memory, read in this order (states are readability only; no content is injected):
+```
+
+```console
+$ agent-memory capture 'Use SQLite for the cache.' --why 'no daemon' --agent codex --home memory --project demo
+captured: /private/tmp/am-readme-demo/memory/projects/demo/memory/decision_log.md (## 2026-09-07)
+- **Use SQLite for the cache.** Why: no daemon (codex, 2026-09-07T01:53:42Z)
+```
+
+```console
+$ agent-memory recall --home memory --project demo --max-chars 850
+## 2026-09-07
+
+- **Use SQLite for the cache.** Why: no daemon (codex, 2026-09-07T01:53:42Z)
+```
+
+```console
+$ agent-memory status --home memory
+home: memory
+source: flag
+exists: yes
+marker: absent
+gitignore: canonical
+org-memory: present
+projects: 1 with a memory dir
+sync: not configured
+```
+
+```console
+$ agent-memory doctor --home memory
+[+] Org Memory
+    [+] org-memory/debriefs/ — present
+    [+] debriefs/ — empty store, nothing to validate
+
+[-] Memory Sync
+    [-] .oacp-memory-repo — not configured; memory sync hooks are disabled
+        Run: agent-memory enable [--remote URL]
+
+No issues found.
+```
+
+## Project
+
+- [PyPI package: agent-memory-cli](https://pypi.org/project/agent-memory-cli/)
+- [Source](https://github.com/kiloloop/agent-memory)
+- [OACP](https://github.com/kiloloop/oacp)
+
+## License
+
+Apache-2.0. See [LICENSE](https://github.com/kiloloop/agent-memory/blob/main/LICENSE).
+
+## Development
+
+Activate `.venv` before running the two `make` commands.
+
+    python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
+    make preflight     # lint, test, build
+    make wheel-check   # install the built wheel in a throwaway venv and prove it operates a home

agent_memory_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+agent_memory/__init__.py,sha256=--LT_n5IN-qMqQNISjOU9x0avYFWh51_XwsL8pTPAYU,316
+agent_memory/__main__.py,sha256=XNI_oqFGNB-_kBZ2_GgnTA43aWGFFftC-rjgEvEwrmM,215
+agent_memory/archive.py,sha256=ABSpaii9ONDxyeaFAqjEDttrIjpFJBZAvrdKWR436jc,15737
+agent_memory/cli.py,sha256=4NiqRFt0ZG2x3efww6fc9yQzq6P2YSoI-Y3fa_5E6oQ,19840
+agent_memory/debrief.py,sha256=mWwPXTXRA7lbYzIk4e4qrUlXu34RZCAaEV1CeY_swSg,12447
+agent_memory/doctor.py,sha256=_m9olIf90dNrJv8tFhSuquhMRdyfiaYtqOicNJV6EMQ,27913
+agent_memory/git_runner.py,sha256=Uk4rGOx2NXoYmY__wUAuKR36dZWSQ-w_LpsI-jO26WY,2184
+agent_memory/home.py,sha256=x3HpOh078AsERKS85ZhVzlCB1v_PCvWyUJlKsionBbQ,9724
+agent_memory/layout.py,sha256=wq8kmXgn7cm0boou2Q9YJFsgEKcFUDtrwhg6iDI5TF4,7153
+agent_memory/org.py,sha256=fjIB_J5uEHqZzLW3mYDL0m1BkSKHrTt11XQbNiN-CMc,8874
+agent_memory/publication.py,sha256=AuZI-cCIKjmtqb_aUOAxEWlxOUrY8Xa1HGPApiGuYLE,19436
+agent_memory/startup.py,sha256=Ks_8svX1XVaWnhMUlOHiKVWexX7-Eyq_EoqEnF5pppg,10697
+agent_memory/status.py,sha256=r63nhpVlJXPeIxsvLABYhfAGjymx3WxOuHR78991-gM,5198
+agent_memory/sync.py,sha256=EbGCPbFTtF159pxtyCnWOEj6z8ho1tnhLflnrGjYP4Y,26429
+agent_memory/workflow.py,sha256=C7A9YFIN_tnr2M3WC4CIP1jfU_4_4czrb89dxIxJIVQ,11169
+agent_memory/setup/__init__.py,sha256=ZRdh5ZKPqud2PRr2QGzLIiybeHSEFZKG79S0rhgYF4M,1048
+agent_memory/setup/claude.py,sha256=w-3SgFiiE1hXc-rnVqIRGoAoYZ4gADsji2RkD-kQ1LY,1371
+agent_memory/setup/codex.py,sha256=pZt4Ff7Qc5-WO12jlWjJb1-RIyT70HFIEzwb0K8YHOA,1702
+agent_memory/setup/common.py,sha256=m1IgTRVDArh6WEGkcKPaNWsxNWxwaCOgt1WN4AUvOhM,40314
+agent_memory/setup/legacy.py,sha256=50vqi_uhtdedl5P29VPQdm6yqnI10aFUmSFtgra1KJY,2198
+agent_memory/templates/org-memory/decisions.md,sha256=Et5wl18CjH467IxFt4mZZLqd49iVJo_yW4KgoKUmNuo,287
+agent_memory/templates/org-memory/recent.md,sha256=cf4gcoXaSpa914c69LGPrRZ61QvbIeSYt-hnFPQjpU0,389
+agent_memory/templates/org-memory/rules.md,sha256=OpmFL4_ZSeb8mRjC8C607FHZXdcM2d8768mXGrO_VPY,283
+agent_memory/templates/project-memory/decision_log.md,sha256=nNmLH635rBi7p26d8YsLcQfXE9ExyLHK4oNj8jvrWi8,96
+agent_memory/templates/project-memory/known_debt.md,sha256=jM5CVGtAfheKjUK4eFA1eSaaE7yLBm9YlmGNHxDUGIY,240
+agent_memory/templates/project-memory/open_threads.md,sha256=0FgTjhFLaZXy19tyJceCUQE_QY-8Lr48Vd0VumbkzRQ,28
+agent_memory/templates/project-memory/project_facts.md,sha256=UIX7_vRJ-tQ5AIT_w1Lzj6n1jhBY4VxyPCLUBfA1-Jg,196
+agent_memory/templates/workflow/SKILL.md,sha256=4GLaQP0xbjrDBy5vDJbnokv7wOgaHVT0SZsQlZkVqco,1980
+agent_memory_cli-0.1.0.dist-info/METADATA,sha256=oXIHdljPWWKZyxlk5sMKeh6yEh_RCCkJjz-photRJwE,10379
+agent_memory_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+agent_memory_cli-0.1.0.dist-info/entry_points.txt,sha256=mG_BjBbd8UY1fAkTlcl2sByYvElm35FtvqUziRuI96Q,55
+agent_memory_cli-0.1.0.dist-info/licenses/LICENSE,sha256=MeRxiQ3KgmBtsOGLgCkYhT5P-aoktQxag0v5CwePUMs,11338
+agent_memory_cli-0.1.0.dist-info/RECORD,,

agent_memory_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_memory_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-memory = agent_memory.cli:main