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

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

@@ -4,6 +4,17 @@ 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.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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-memory-cli
-Version: 0.1.1
+Version: 0.1.2
 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

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.2}/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.2}/src/agent_memory/__init__.py

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

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.2}/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(
@@ -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:

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.2}/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.2/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.2}/src/agent_memory/status.py

@@ -7,20 +7,23 @@ project), the layout (marker, allowlist, tiers), and, when the home is a sync
 repository, its :class:`~agent_memory.sync.GitState`. The remote is contacted
 only with ``--fetch``; otherwise ahead/behind count against the last fetched
 upstream. Exit 0 when the tree is clean and not diverged, 1 when it is dirty
-or diverged (or the home does not exist). Ahead and behind are reported, not
-failed: they are what ``push`` and ``pull`` are for.
+or diverged, or a prerequisite failed (:mod:`agent_memory.prerequisites`).
+Ahead and behind are reported, not failed: they are what ``push`` and ``pull``
+are for. ``--json`` prints the same readout as data, with ``ok`` true exactly
+when the exit is 0.
 """
 
 from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
-from . import layout, sync
-from .doctor import enclosing_repository, sync_state_text
+from . import layout, prerequisites, sync
+from .doctor import enclosing_repository, sync_state, sync_state_text
 from .git_runner import GitRunner
 from .home import HomeResolution
+from .prerequisites import Prerequisites
 from .sync import GitState
 
 EXIT_OK = 0
@@ -39,13 +42,14 @@ class Status:
     gitignore: str = ""
     org_memory: bool = False
     projects: int = 0
-    #: ``None`` without the marker; otherwise whether the home is a git repository.
+    #: ``None`` without the marker or without git; otherwise whether the home is a git repository.
     repository: Optional[bool] = None
     #: Set when the home is a repository only by sitting inside another one.
     enclosing: Optional[Path] = None
     git: Optional[GitState] = None
     #: Whether the remote was contacted for this readout.
     fetched: bool = False
+    prerequisites: Prerequisites = Prerequisites()
 
     @property
     def clean(self) -> bool:
@@ -54,9 +58,13 @@ class Status:
             return False
         return self.git is None or not (self.git.dirty or self.git.diverged)
 
+    @property
+    def ok(self) -> bool:
+        return self.prerequisites.ok and self.clean
+
     @property
     def exit_code(self) -> int:
-        return EXIT_OK if self.clean else EXIT_FAILED
+        return EXIT_OK if self.ok else EXIT_FAILED
 
     def lines(self) -> List[str]:
         lines = [f"home: {self.home}", f"source: {self.source}"]
@@ -64,7 +72,7 @@ class Status:
             lines.append(f"project: {self.project}")
         if not self.exists:
             lines.append("exists: no")
-            return lines
+            return self._with_failure(lines)
         lines.extend(
             [
                 "exists: yes",
@@ -74,8 +82,10 @@ class Status:
                 f"projects: {self.projects} with a memory dir",
             ]
         )
-        if self.repository is None:
+        if not self.marker:
             lines.append("sync: not configured")
+        elif self.prerequisites.reason == prerequisites.GIT_MISSING:
+            lines.append(f"sync: not read ({prerequisites.GIT_MISSING})")
         elif not self.repository:
             lines.append("sync: marker present, but the home is not a git repository")
         elif self.enclosing is not None:
@@ -85,26 +95,70 @@ class Status:
             if self.git.has_remote:
                 lines.append("fetch: done" if self.fetched else "fetch: skipped (pass --fetch to contact the remote)")
             lines.append(f"tree: {'dirty' if self.git.dirty else 'clean'}")
-        return lines
+        return self._with_failure(lines)
+
+    def _with_failure(self, lines: List[str]) -> List[str]:
+        failure = self.prerequisites.failure
+        return lines + [f"prerequisite failed: {failure.line()}"] if failure else lines
+
+    def to_json(self) -> Dict[str, Any]:
+        """The readout as data: the fields the lines show, and ``ok`` for the exit code."""
+        git = self.git
+        return {
+            "ok": self.ok,
+            "home": str(self.home),
+            "source": self.source,
+            "project": self.project,
+            "exists": self.exists,
+            "layout": {
+                "marker": self.marker,
+                "gitignore": self.gitignore,
+                "org_memory": self.org_memory,
+                "projects": self.projects,
+            }
+            if self.exists
+            else None,
+            "sync": {
+                "configured": self.marker,
+                "repository": self.repository,
+                "enclosing": str(self.enclosing) if self.enclosing is not None else None,
+                "state": sync_state(git) if git else None,
+                "state_text": sync_state_text(git) if git else None,
+                "remote": git.has_remote if git else None,
+                "upstream": (git.upstream or None) if git else None,
+                "fetched": self.fetched,
+                "ahead": git.ahead if git else None,
+                "behind": git.behind if git else None,
+                "dirty": git.dirty if git else None,
+                "diverged": git.diverged if git else None,
+            }
+            if self.exists
+            else None,
+            "prerequisites": self.prerequisites.to_json(),
+        }
 
 
 def inspect(resolution: HomeResolution, *, fetch: bool = False, runner: Optional[GitRunner] = None) -> Status:
     """Read the home ``resolution`` names; nothing is changed, and no network without ``fetch``."""
     home = resolution.path
     if not home.is_dir():
-        return Status(home, resolution.source, resolution.project, exists=False)
+        return Status(
+            home, resolution.source, resolution.project, exists=False, prerequisites=prerequisites.home_missing(home)
+        )
     tiers = layout.allowed_memory_dirs(home)
     org = layout.org_memory_dir(home)
     marker = sync.is_configured(home)
+    probe = prerequisites.probe_git(runner)
     repository: Optional[bool] = None
     enclosing: Optional[Path] = None
     git: Optional[GitState] = None
-    if marker:
+    if marker and probe.present:
         repository = sync.is_git_repo(home, runner)
         if repository:
             enclosing = enclosing_repository(home, runner)
         if repository and enclosing is None:
             git = sync.git_state(home, runner=runner, fetch=fetch)
+    fetched = fetch and git is not None and git.has_remote
     return Status(
         home,
         resolution.source,
@@ -117,10 +171,25 @@ def inspect(resolution: HomeResolution, *, fetch: bool = False, runner: Optional
         repository=repository,
         enclosing=enclosing,
         git=git,
-        fetched=fetch and git is not None and git.has_remote,
+        fetched=fetched,
+        prerequisites=prerequisites.assess(probe, configured=marker, state=git, fetched=fetched),
     )
 
 
+def unresolved(error: Exception) -> Dict[str, Any]:
+    """The JSON readout when the resolver itself failed, so there is no home to read."""
+    return {
+        "ok": False,
+        "home": None,
+        "source": None,
+        "project": None,
+        "exists": False,
+        "layout": None,
+        "sync": None,
+        "prerequisites": prerequisites.home_error(error).to_json(),
+    }
+
+
 def gitignore_state(home: Path) -> str:
     """How the root ``.gitignore`` relates to the canonical allowlist, in a few words."""
     path = home / layout.GITIGNORE_FILE

{agent_memory_cli-0.1.1 → agent_memory_cli-0.1.2}/src/agent_memory/sync.py

@@ -547,7 +547,7 @@ def _deliver(
     receipt: Optional[GitignoreReceipt] = None,
 ) -> Outcome:
     if state.fetch_failed:
-        if _credential_helper_blocked(state.fetch_output):
+        if credential_helper_blocked(state.fetch_output):
             return _helper_blocked(lines, published, receipt)
         failure = _fetch_failure(state, "memory push")
         lines.append(f"{failure.lines[0]} The commit remains local.")
@@ -557,7 +557,7 @@ def _deliver(
         return Outcome("up_to_date", True, tuple(lines), (), published.preserved, receipt)
     result = _push_remote(home, state, runner)
     if not result.ok:
-        if _credential_helper_blocked(result.output):
+        if credential_helper_blocked(result.output):
             return _helper_blocked(lines, published, receipt)
         what = "timed out" if result.timed_out else "was rejected"
         lines.append(f"memory push: the push {what}; the commit remains local. {result.output}".rstrip())
@@ -575,9 +575,10 @@ def _push_remote(home: Path, state: GitState, runner: Optional[GitRunner]) -> Gi
     return _git(home, ["push", "--quiet", "-u", remote, branch], runner, timeout=NETWORK_TIMEOUT_SECONDS)
 
 
-def _credential_helper_blocked(output: str) -> bool:
+def credential_helper_blocked(output: str) -> bool:
     """Does this git failure carry the blocked-credential-helper signature?
 
+    The one detector: ``doctor`` and ``status`` read fetch output through it too.
     git falls back to prompting when a helper hands it nothing, and under a
     sandbox that prompt has no terminal to read from either. Both halves are
     required, and the second must come from the helper: a prompt failure on