agent-memory-cli 0.1.1__tar.gz → 0.1.3__tar.gz

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to agent-memory are documented in this file. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.3 - 2026-09-29
+
+### Fixed
+
+- `pull`, `push`, and SessionStart sync can resolve homes with local memory changes behind upstream ([sync](docs/commands.md#sync)).
+
+## 0.1.2 - 2026-09-17
+
+### Added
+
+- `status --json` prints the readout as one object, with an `ok` flag and a `prerequisites` block ([status](docs/commands.md#status)).
+
+### Fixed
+
+- `status` and `doctor` exit non-zero with a reason code when a prerequisite such as git fails ([prerequisites](docs/commands.md#prerequisites)).
+- `doctor` and `status --fetch` name a sandbox-blocked credential helper, not an unreachable remote ([doctor](docs/commands.md#doctor)).
+
 ## 0.1.1 - 2026-09-12
 
 ### Added

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-memory-cli
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -105,7 +105,7 @@ Python 3.10+ is required; sync needs git 2.25+, hooks use Bash, and
    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
+   agent-memory pull --agent claude
    ```
 
    Elsewhere, `agent-memory clone <remote-url> --home <local-home>`, then repeat
@@ -141,13 +141,14 @@ 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.
+marker. `push` and `pull --agent NAME` commit selected paths, rebase when behind,
+and deliver. A plain `pull` updates a clean tree and reports unpushed commits.
+Conflicts abort the rebase and retain local commits. Keys and setup receipts
+stay local. Network and rebase operations 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
+injects no content. `--pull` commits and syncs first under the runtime identity, 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

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/README.md

@@ -75,7 +75,7 @@ Python 3.10+ is required; sync needs git 2.25+, hooks use Bash, and
    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
+   agent-memory pull --agent claude
    ```
 
    Elsewhere, `agent-memory clone <remote-url> --home <local-home>`, then repeat
@@ -111,13 +111,14 @@ 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.
+marker. `push` and `pull --agent NAME` commit selected paths, rebase when behind,
+and deliver. A plain `pull` updates a clean tree and reports unpushed commits.
+Conflicts abort the rebase and retain local commits. Keys and setup receipts
+stay local. Network and rebase operations 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
+injects no content. `--pull` commits and syncs first under the runtime identity, 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

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling>=1.27"]
+requires = ["hatchling>=1.32,<2"]
 build-backend = "hatchling.build"
 
 [project]

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/src/agent_memory/__init__.py

@@ -4,6 +4,6 @@
 
 from .home import HomeError, HomeResolution, resolve_home
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"
 
 __all__ = ["HomeError", "HomeResolution", "__version__", "resolve_home"]

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/src/agent_memory/cli.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 from typing import Callable, List, Optional, Sequence, Tuple
 
-from . import __version__, archive, debrief, doctor, events, org, setup, startup, status, sync, workflow
+from . import __version__, archive, debrief, doctor, events, org, prerequisites, setup, startup, status, sync, workflow
 from .home import BINDING_FILE, HomeError, HomeResolution, find_project, resolve_home
 
 EXIT_OK = 0
@@ -51,16 +51,17 @@ def build_parser() -> argparse.ArgumentParser:
         "status",
         _status,
         "Show which home resolves, which rule chose it, whether the layout is in place, and where the sync stands. "
-        "Exit 1 when the tree is dirty or diverged.",
+        "Exit 1 when the tree is dirty or diverged, or a prerequisite (git, the home, the credential helper) failed.",
     )
     status_.add_argument(
         "--fetch", action="store_true", help="contact the remote before counting ahead/behind (no network otherwise)"
     )
+    status_.add_argument("--json", dest="json_output", action="store_true", help="emit the readout as JSON")
     doctor_ = add(
         "doctor",
         _doctor,
         "Check the home's setup and health: the debrief store's layout and the sync repository. "
-        "Reads no memory content; repairs nothing. Exit 1 on an error row.",
+        "Reads no memory content; repairs nothing. Exit 1 on an error row or a failed prerequisite.",
     )
     doctor_.add_argument("--json", dest="json_output", action="store_true", help="emit the report as JSON")
     init_ = add(
@@ -91,7 +92,7 @@ def build_parser() -> argparse.ArgumentParser:
     clone_ = add("clone", _clone, "Clone a memory repository into the home.")
     clone_.add_argument("url", help="git remote URL to clone")
     clone_.add_argument("--force", action="store_true", help="move a non-empty home aside before cloning")
-    add("pull", _pull, "Fast-forward the home from its upstream when the tree is clean and not ahead.")
+    add("pull", _pull, "Update from upstream; with --agent, commit allowlisted changes and deliver them too.", agent)
     add("push", _push, "Commit the allowlisted memory changes and push them when a remote exists.", agent)
     add("disable", _disable, "Remove the sync marker; the repository stays in place.")
     for name, handler, help_text, positional, positional_help in (
@@ -120,7 +121,7 @@ def build_parser() -> argparse.ArgumentParser:
         "startup",
         _startup,
         "Print the session-start manifest: the memory files to read, in order, with their readability, size and "
-        "age, and where the sync stands. Content is never included. With --pull, fast-forward the home first.",
+        "age, and where the sync stands. Content is never included. With --pull, commit and sync memory under the runtime identity first.",
     )
     startup_.add_argument("--runtime", choices=startup.RUNTIMES, required=True, help="shape the output for this runtime's hook")
     startup_.add_argument("--project", metavar="ID", help="the project tier to list (default: the one the binding or marker names)")
@@ -235,23 +236,44 @@ def _max_chars(value: str) -> int:
 
 
 def _status(args: argparse.Namespace) -> int:
-    readout = status.inspect(resolve_home(args.home), fetch=args.fetch)
-    print("\n".join(readout.lines()))
+    try:
+        resolution = resolve_home(args.home)
+    except HomeError as exc:
+        if not args.json_output:
+            raise
+        print(json.dumps(status.unresolved(exc), indent=2))
+        return EXIT_USAGE
+    readout = status.inspect(resolution, fetch=args.fetch)
+    if args.json_output:
+        print(json.dumps(readout.to_json(), indent=2))
+    else:
+        print("\n".join(readout.lines()))
     return readout.exit_code
 
 
 def _doctor(args: argparse.Namespace) -> int:
-    home = resolve_home(args.home).path
+    memory_lint = doctor.find_memory_lint()
+    try:
+        home = resolve_home(args.home).path
+    except HomeError as exc:
+        if not args.json_output:
+            raise
+        unresolved = prerequisites.home_error(exc)
+        print(json.dumps(doctor.to_json([], memory_lint=memory_lint, prerequisites=unresolved), indent=2))
+        return EXIT_USAGE
     if not home.is_dir():
-        print(f"agent-memory: error: {home} is not a directory", file=sys.stderr)
+        missing = prerequisites.home_missing(home)
+        if args.json_output:
+            print(json.dumps(doctor.to_json([], memory_lint=memory_lint, prerequisites=missing), indent=2))
+        elif missing.failure:
+            print(f"agent-memory: error: {missing.failure.line()}", file=sys.stderr)
         return EXIT_FAILED
-    categories = doctor.run_doctor(home)
-    memory_lint = doctor.find_memory_lint()
+    categories, readout = doctor.diagnose(home)
     if args.json_output:
-        print(json.dumps(doctor.to_json(categories, memory_lint=memory_lint), indent=2))
+        print(json.dumps(doctor.to_json(categories, memory_lint=memory_lint, prerequisites=readout), indent=2))
     else:
         sys.stdout.write(doctor.report(categories, memory_lint=memory_lint))
-    return EXIT_FAILED if doctor.has_errors(categories) else EXIT_OK
+    return EXIT_FAILED if doctor.has_errors(categories) or not readout.ok else EXIT_OK
 
 
 def _init(args: argparse.Namespace) -> int:
@@ -275,7 +297,7 @@ def _clone(args: argparse.Namespace) -> int:
 
 
 def _pull(args: argparse.Namespace) -> int:
-    return _report(sync.pull(resolve_home(args.home).path))
+    return _report(sync.pull(resolve_home(args.home).path, agent=args.agent))
 
 
 def _push(args: argparse.Namespace) -> int:

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/src/agent_memory/doctor.py

@@ -36,8 +36,9 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 
-from . import layout, sync
+from . import layout, prerequisites, sync
 from .git_runner import GitResult, GitRunner, run_git
+from .prerequisites import Prerequisites
 from .sync import GitState
 
 #: A last commit older than this many days is reported stale.
@@ -109,7 +110,15 @@ def run_doctor(
     home: Path, *, runner: Optional[GitRunner] = None, now: Optional[dt.datetime] = None
 ) -> List[Category]:
     """Both memory categories for ``home``, in report order."""
-    return [check_org_memory(home), check_memory_sync(home, runner=runner, now=now)]
+    return diagnose(home, runner=runner, now=now)[0]
+
+
+def diagnose(
+    home: Path, *, runner: Optional[GitRunner] = None, now: Optional[dt.datetime] = None
+) -> Tuple[List[Category], Prerequisites]:
+    """Both memory categories in report order, and the prerequisite readout the sync checks took."""
+    memory_sync, readout = _memory_sync(home, runner=runner, now=now)
+    return [check_org_memory(home), memory_sync], readout
 
 
 def find_memory_lint(which: Callable[[str], Optional[str]] = shutil.which) -> Optional[str]:
@@ -135,10 +144,16 @@ def report(categories: Sequence[Category], *, memory_lint: Optional[str] = None)
     return "\n".join(lines) + "\n"
 
 
-def to_json(categories: Sequence[Category], *, memory_lint: Optional[str] = None) -> Dict[str, Any]:
-    """The report as data, in the same order as the text."""
+def to_json(
+    categories: Sequence[Category],
+    *,
+    memory_lint: Optional[str] = None,
+    prerequisites: Optional[Prerequisites] = None,
+) -> Dict[str, Any]:
+    """The report as data, in the same order as the text; ``prerequisites`` goes last, so the
+    rows before it read as they did without it."""
     output: Dict[str, Any] = {
-        "has_errors": has_errors(categories),
+        "has_errors": has_errors(categories) or (prerequisites is not None and not prerequisites.ok),
         "memory_lint": memory_lint,
         "categories": [],
     }
@@ -152,6 +167,8 @@ def to_json(categories: Sequence[Category], *, memory_lint: Optional[str] = None
         output["categories"].append(
             {"name": category.name, "worst_severity": category.worst_severity.value, "results": rows}
         )
+    if prerequisites is not None:
+        output["prerequisites"] = prerequisites.to_json()
     return output
 
 
@@ -325,14 +342,21 @@ def check_memory_sync(
     home: Path, *, runner: Optional[GitRunner] = None, now: Optional[dt.datetime] = None
 ) -> Category:
     """The sync setup and the repository's state, through git alone; nothing is changed."""
+    return _memory_sync(home, runner=runner, now=now)[0]
+
+
+def _memory_sync(
+    home: Path, *, runner: Optional[GitRunner], now: Optional[dt.datetime]
+) -> Tuple[Category, Prerequisites]:
     cat = Category("Memory Sync")
     marker = layout.MARKER_FILE
+    git = prerequisites.probe_git(runner)
 
     try:
         configured = _is_file(sync.marker_path(home))
     except OSError as exc:
         cat.add("memory-marker", Severity.warn, f"{marker} — {_not_inspected(exc)}")
-        return cat
+        return cat, prerequisites.assess(git, configured=False)
     if not configured:
         cat.add(
             "memory-marker",
@@ -340,9 +364,18 @@ def check_memory_sync(
             f"{marker} — not configured; memory sync hooks are disabled",
             "Run: agent-memory enable [--remote URL]",
         )
-        return cat
+        return cat, prerequisites.assess(git, configured=False)
     cat.add("memory-marker", Severity.ok, f"{marker} — present")
 
+    if not git.present:
+        # Without git every readout below fails, and "not a git repository" would be the wrong finding.
+        cat.add(
+            "memory-git",
+            Severity.error,
+            f"{marker} — present, but {prerequisites.GIT_MISSING_TEXT}",
+            prerequisites.GIT_MISSING_REMEDY,
+        )
+        return cat, prerequisites.assess(git, configured=True)
     if not sync.is_git_repo(home, runner):
         cat.add(
             "memory-git",
@@ -350,7 +383,7 @@ def check_memory_sync(
             f"{marker} — present, but {home} is not a git repository",
             "Run `agent-memory enable`, or `agent-memory disable` to remove the marker",
         )
-        return cat
+        return cat, prerequisites.assess(git, configured=True)
     enclosing = enclosing_repository(home, runner)
     if enclosing is not None:
         # The sync verbs refuse this home; reading the enclosing repository's state as the home's would be wrong.
@@ -361,7 +394,7 @@ def check_memory_sync(
             "a memory home must be the root of its own repository",
             "Move the home out of the enclosing repository, or `agent-memory disable` to remove the marker",
         )
-        return cat
+        return cat, prerequisites.assess(git, configured=True)
 
     root_gitignore = home / layout.GITIGNORE_FILE
     try:
@@ -450,6 +483,10 @@ def check_memory_sync(
         if not state.has_remote:
             cat.add("sync-state", Severity.ok, text)
             cat.add("remote", Severity.skip, "remote — skipped; local-only memory repo")
+        elif prerequisites.helper_blocked(state):
+            # Not the network and not the remote's permissions: git never had credentials to try with.
+            cat.add("sync-state", Severity.error, text, prerequisites.HELPER_BLOCKED_REMEDY)
+            cat.add("remote", Severity.skip, "remote — not checked; the sandbox blocked the git credential helper")
         elif state.fetch_failed:
             cat.add("sync-state", Severity.warn, text, "Check network access and remote permissions")
             cat.add("remote", Severity.warn, "remote — not reachable", "Check network access and remote permissions")
@@ -523,7 +560,8 @@ def check_memory_sync(
     else:
         cat.add("memory-overlays", Severity.ok, f"memory .gitignore overlays — {len(overlays)} safe")
 
-    return cat
+    fetched = state is not None and state.has_remote
+    return cat, prerequisites.assess(git, configured=True, state=state, fetched=fetched)
 
 
 def _add_working_tree(cat: Category, home: Path, runner: Optional[GitRunner], state: GitState) -> None:
@@ -568,10 +606,30 @@ def enclosing_repository(home: Path, runner: Optional[GitRunner] = None) -> Opti
     return root
 
 
+def sync_state(state: GitState) -> str:
+    """Where the repository stands, as the code ``status --json`` carries beside :func:`sync_state_text`."""
+    if not state.has_remote:
+        return "local_only"
+    if state.fetch_failed:
+        return "fetch_failed"
+    if not state.has_upstream:
+        return "no_upstream"
+    if state.diverged:
+        return "diverged"
+    if state.behind:
+        return "behind"
+    if state.ahead:
+        return "ahead"
+    return "synced"
+
+
 def sync_state_text(state: GitState) -> str:
     """One phrase for where the repository stands; ``status`` and ``doctor`` share it."""
     if not state.has_remote:
         return "local-only; no remote configured"
+    if prerequisites.helper_blocked(state):
+        # The helper's own output names the secret it was after; the phrase names the cause instead.
+        return f"remote fetch failed: {prerequisites.HELPER_BLOCKED_TEXT}"
     if state.fetch_failed:
         return f"remote fetch failed: {state.fetch_output}"
     if not state.has_upstream:

agent_memory_cli-0.1.3/src/agent_memory/prerequisites.py

@@ -0,0 +1,151 @@
+# SPDX-FileCopyrightText: 2026 Kiloloop
+# SPDX-License-Identifier: Apache-2.0
+"""What ``status`` and ``doctor`` need before their readout means anything.
+
+Three prerequisite failures, each with a stable reason code. The JSON carries
+the code and the message, the table prints the same message, and either verb
+exits non-zero on any of them:
+
+* ``home_unresolved``: no memory home. The resolver failed, or the path it
+  chose is not a directory.
+* ``git_missing``: git does not run, on a home that carries the sync marker. A
+  home without the marker needs no git, so there its absence is reported, not
+  failed. Without git a marked home would read as "not a git repository",
+  which is a layout finding it is not.
+* ``credential_helper_blocked``: a fetch failed with the signature
+  :func:`agent_memory.sync.credential_helper_blocked` detects, a git
+  credential helper that a sandbox stopped. The helper runs only when git has
+  no cached credential for the remote, so the failure needs a cold cache as
+  well as the sandbox.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from . import sync
+from .git_runner import EXIT_NOT_FOUND, GitRunner, run_git
+from .sync import GitState
+
+HOME_UNRESOLVED = "home_unresolved"
+GIT_MISSING = "git_missing"
+CREDENTIAL_HELPER_BLOCKED = "credential_helper_blocked"
+#: Every reason code, in the order the checks run.
+REASONS = (HOME_UNRESOLVED, GIT_MISSING, CREDENTIAL_HELPER_BLOCKED)
+
+GIT_MISSING_TEXT = "git could not be run from PATH"
+GIT_MISSING_REMEDY = "Install git, or put it on PATH"
+HELPER_BLOCKED_TEXT = (
+    "the git credential helper could not run under the sandbox, so git had no credentials for the remote"
+)
+HELPER_BLOCKED_REMEDY = "Rerun with the sandbox off"
+HOME_MISSING_REMEDY = "Pass --home or set $AGENT_MEMORY_HOME to an existing home, or create one with `agent-memory init`"
+HOME_ERROR_REMEDY = "Fix the binding or path it names, or pass --home"
+
+
+@dataclass(frozen=True)
+class Failure:
+    """One failed prerequisite: its reason code, what happened, and what to do."""
+
+    reason: str
+    message: str
+    remedy: str
+
+    def line(self) -> str:
+        return f"{self.reason} — {self.message}. {self.remedy}."
+
+
+@dataclass(frozen=True)
+class GitProbe:
+    """Whether git runs, and the version it reports (empty when it reported none)."""
+
+    present: bool
+    version: str = ""
+
+
+@dataclass(frozen=True)
+class Prerequisites:
+    """The prerequisite readout both verbs print."""
+
+    #: ``None`` when git was not probed, because there was no home to probe it in.
+    git: Optional[GitProbe] = None
+    #: Whether a fetch ran, the only time the credential helper can be judged.
+    helper_checked: bool = False
+    helper_blocked: bool = False
+    failure: Optional[Failure] = None
+
+    @property
+    def ok(self) -> bool:
+        return self.failure is None
+
+    @property
+    def reason(self) -> Optional[str]:
+        return self.failure.reason if self.failure else None
+
+    def to_json(self) -> Dict[str, Any]:
+        failure = self.failure
+        return {
+            "ok": self.ok,
+            "reason": failure.reason if failure else None,
+            "message": failure.message if failure else None,
+            "remedy": failure.remedy if failure else None,
+            "git": {
+                "present": self.git.present if self.git else None,
+                "version": (self.git.version or None) if self.git else None,
+            },
+            "credential_helper": {
+                "checked": self.helper_checked,
+                "blocked": self.helper_blocked if self.helper_checked else None,
+            },
+        }
+
+
+#: Where the probe runs git. ``git --version`` reads nothing from its working directory, and the
+#: filesystem root is always there, so a missing or unreadable home cannot pass for a missing git.
+_PROBE_CWD = Path(os.path.abspath(os.sep))
+
+
+def probe_git(runner: Optional[GitRunner] = None) -> GitProbe:
+    """Run ``git --version``. A git absent from PATH, or one the system will not execute, does not run."""
+    try:
+        result = (runner or run_git)(["--version"], cwd=_PROBE_CWD)
+    except OSError:
+        # The runner reports an absent git itself; this is a git it found and could not execute.
+        return GitProbe(False)
+    if result.returncode == EXIT_NOT_FOUND:
+        return GitProbe(False)
+    words = result.stdout.split()
+    version = words[2] if result.ok and words[:2] == ["git", "version"] and len(words) > 2 else ""
+    return GitProbe(True, version)
+
+
+def helper_blocked(state: Optional[GitState]) -> bool:
+    """Did this readout's fetch fail because a sandbox blocked the credential helper?"""
+    return state is not None and state.fetch_failed and sync.credential_helper_blocked(state.fetch_output)
+
+
+def home_missing(home: Path) -> Prerequisites:
+    return Prerequisites(failure=Failure(HOME_UNRESOLVED, f"{home} is not a directory", HOME_MISSING_REMEDY))
+
+
+def home_error(error: Exception) -> Prerequisites:
+    return Prerequisites(
+        failure=Failure(HOME_UNRESOLVED, f"the memory home could not be resolved: {error}", HOME_ERROR_REMEDY)
+    )
+
+
+def assess(
+    git: GitProbe, *, configured: bool, state: Optional[GitState] = None, fetched: bool = False
+) -> Prerequisites:
+    """The readout for a home that exists. Git is required once the home carries the sync
+    marker; the credential helper is judged only when ``fetched``."""
+    blocked = fetched and helper_blocked(state)
+    failure: Optional[Failure] = None
+    if configured and not git.present:
+        failure = Failure(GIT_MISSING, GIT_MISSING_TEXT, GIT_MISSING_REMEDY)
+    elif blocked:
+        failure = Failure(CREDENTIAL_HELPER_BLOCKED, HELPER_BLOCKED_TEXT, HELPER_BLOCKED_REMEDY)
+    return Prerequisites(git, fetched, blocked, failure)

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.3}/src/agent_memory/startup.py

@@ -72,7 +72,7 @@ def build_manifest(
     warnings: List[str] = list(notes)
     files: List[Dict[str, Any]] = []
 
-    sync_info, pull_info = _sync(home, pull, runner, warnings)
+    sync_info, pull_info = _sync(home, pull, runner, warnings, runtime)
     if project is not None:
         try:
             layout.validate_project_name(project)
@@ -154,14 +154,14 @@ def _entry(home: Path, path: Path, tier: str, name: str) -> Dict[str, Any]:
 
 
 def _sync(
-    home: Path, pull: bool, runner: Optional[GitRunner], warnings: List[str]
+    home: Path, pull: bool, runner: Optional[GitRunner], warnings: List[str], runtime: str
 ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
     marker = sync.is_configured(home)
     info: Dict[str, Any] = {"marker": marker, "last_commit_at_utc": None}
     pull_info: Dict[str, Any] = {"requested": pull, "status": PULL_NOT_REQUESTED, "ok": True, "lines": []}
     if pull:
         try:
-            outcome = sync.pull(home, runner=runner)
+            outcome = sync.pull(home, agent=runtime, runner=runner)
             pull_info = {"requested": True, "status": outcome.status, "ok": outcome.ok, "lines": list(outcome.lines)}
         except (sync.SyncError, OSError) as exc:
             pull_info = {"requested": True, "status": PULL_ERROR, "ok": False, "lines": [f"memory pull: {exc}"]}