graphite-code 0.5.1__tar.gz → 0.5.2__tar.gz

{graphite_code-0.5.1 → graphite_code-0.5.2}/CHANGELOG.md

@@ -12,6 +12,35 @@ machine-checkable identity; the version is for humans.
 
 [Keep a Changelog]: https://keepachangelog.com/en/1.1.0/
 
+## [0.5.2] — 2026-08-28
+
+### Fixed
+
+**Force-stopping the daemon mid-build no longer wedges its successor for the
+lock TTL** (#60). The build lock was held by the daemon on its child's behalf
+(`ENV_LOCK_HELD` told the child not to contend), so `Stop-Process -Force` --
+the documented post-install restart, which runs no `finally` -- left
+`.build.lock` on disk naming a dead pid while the orphaned child kept writing
+`graph-out/`. The successor could neither trust "holder dead" (the writer was
+still alive) nor see "writer done", so it logged `build_skipped_locked` every
+cycle and `daemon-health` warned for up to 600 s over a graph that was already
+correct. A pid-liveness probe would not have helped and would have raced the
+orphan in the very incident that filed the issue.
+
+The lock now follows the writer: the daemon's child takes it itself, exactly
+as a hook or manual `graphite build` does, and a killed daemon leaves no lock
+at all. `build_skipped_locked` is therefore true for as long as a build is
+really running and not a second longer. Two consequences are handled. The
+child answers a refusal with exit status 75 (`EX_TEMPFAIL`) when the daemon
+asks for it via `GRAPHITE_BUILD_LOCK_REPORT_REFUSAL`, so the cycle can book
+"another builder owns the repo" as a skip and not a failed build; a human or a
+hook still gets exit 0. And because the daemon's timeout kill now kills the
+holder, the daemon releases the lock its dead child left -- by pid match only,
+never by guessing. Under a Windows venv launcher `Popen.pid` is the launcher,
+not the writer, so there the timeout path falls back to the TTL instead of
+retrying next cycle: conservative by design, and noted here so nobody reads it
+as a hang. `GRAPHITE_BUILD_LOCK_HELD` is gone; nothing outside the daemon set it.
+
 ## [0.5.1] — 2026-08-27
 
 ### Fixed

{graphite_code-0.5.1 → graphite_code-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphite-code
-Version: 0.5.1
+Version: 0.5.2
 Summary: Local-first, zero-LLM knowledge graph extraction for codebases.
 Project-URL: Homepage, https://github.com/jared0565/graphite
 Project-URL: Repository, https://github.com/jared0565/graphite

{graphite_code-0.5.1 → graphite_code-0.5.2}/src/graphite/__init__.py

@@ -38,4 +38,4 @@ __all__ = ["__version__"]
 #: Coarse and hand-maintained by construction. It is a release label, not
 #: evidence that a given fix is present -- to answer that, survey for the marker
 #: the fix introduced, or compare `graphite --version` fingerprints.
-__version__ = "0.5.1"
+__version__ = "0.5.2"

{graphite_code-0.5.1 → graphite_code-0.5.2}/src/graphite/buildlock.py

@@ -9,6 +9,14 @@ Staleness is TTL-only, deliberately. `os.kill(pid, 0)` is the obvious liveness
 idiom and is WRONG here: on Windows, Python's `os.kill` ignores signal 0 and
 calls TerminateProcess, so the portable-looking probe would kill the very
 process it was checking.
+
+The holder must be the process that writes (#60). The daemon used to take the
+lock and hand its child an escape hatch; force-stopping the daemon then left
+the record on disk with a dead pid while the orphaned child kept writing
+graph-out/, and the successor could neither trust "holder dead" nor see
+"writer done" -- so it skipped the repo for the whole TTL. Liveness probing
+would not have helped: the recorded pid was dead while the writer was alive.
+With the writer as holder, its death and its writes end together.
 """
 from __future__ import annotations
 
@@ -24,9 +32,13 @@ from typing import Any, Callable, Iterator
 # holding the lock past double the daemon's give-up point is dead by definition.
 DEFAULT_TTL_SECONDS = 600.0
 
-# Set by a parent that already holds the lock, so its child does not deadlock
-# against it. Mirrors the existing GRAPHITE_DAEMON_CHILD convention.
-ENV_LOCK_HELD = "GRAPHITE_BUILD_LOCK_HELD"
+# A builder that cannot take the lock exits 0: a skipped build is a normal
+# outcome for a human or a git hook, not a failure. The daemon needs more --
+# "another builder owns the repo" must not be booked as a failed build -- so
+# it sets this in its child's environment, and the child answers a refusal
+# with REFUSED_EXIT_STATUS instead. Mirrors the GRAPHITE_DAEMON_CHILD convention.
+ENV_REPORT_REFUSAL = "GRAPHITE_BUILD_LOCK_REPORT_REFUSAL"
+REFUSED_EXIT_STATUS = 75  # sysexits.h EX_TEMPFAIL: try again later
 
 
 def lock_path(cache_dir: Path) -> Path:
@@ -50,6 +62,44 @@ def _is_stale(record: dict[str, Any] | None, now: float, ttl_seconds: float) ->
     return (now - float(started)) > ttl_seconds
 
 
+def is_held(
+    cache_dir: Path,
+    *,
+    ttl_seconds: float = DEFAULT_TTL_SECONDS,
+    clock: Callable[[], float] = time.time,
+) -> bool:
+    """Advisory: would a builder be refused right now?
+
+    Reads only -- never acquires, never unlinks, never steals. The answer can
+    be stale by the time the caller acts on it, so correctness still rests on
+    the acquirer's own `build_lock`. The daemon uses it to avoid spawning a
+    child every cycle only to have it refused.
+    """
+    path = lock_path(cache_dir)
+    if not path.exists():
+        return False
+    return not _is_stale(_read_record(path), clock(), ttl_seconds)
+
+
+def release_if_held_by(cache_dir: Path, *, pid: int) -> bool:
+    """Unlink the lock if its record names `pid`; True if it did.
+
+    For a parent that has just killed `pid`: the child died without its
+    `finally`, and no other process can hold a record carrying its pid, so this
+    releases on the dead child's behalf rather than stealing. It is NOT a
+    liveness probe -- the caller must already know the process is dead.
+    """
+    path = lock_path(cache_dir)
+    record = _read_record(path)
+    if record is None or record.get("pid") != pid:
+        return False
+    try:
+        path.unlink()
+    except OSError:
+        return False
+    return True
+
+
 def _create_exclusive(path: Path, now: float) -> bool:
     """Atomically create the lock file. False if someone else already has it."""
     try: