brigade-cli 0.9.2__tar.gz → 0.10.0__tar.gz

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: brigade-cli
-Version: 0.9.2
+Version: 0.10.0
 Summary: AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, Hermes, and OpenClaw.
 Author-email: Solomon Neas <srneas@gmail.com>
 License: MIT
 Project-URL: Homepage, https://brigade.tools
 Project-URL: Repository, https://github.com/escoffier-labs/brigade
-Project-URL: Cookbook, https://github.com/solomonneas/solos-cookbook
+Project-URL: Cookbook, https://github.com/escoffier-labs/solos-cookbook
 Project-URL: OpenClaw, https://github.com/solomonneas/openclaw
-Project-URL: ContentGuard, https://github.com/solomonneas/content-guard
+Project-URL: ContentGuard, https://github.com/escoffier-labs/content-guard
 Project-URL: AgentPantry, https://github.com/escoffier-labs/agentpantry
 Project-URL: Issues, https://github.com/escoffier-labs/brigade/issues
 Keywords: agents,ai-agents,agent-memory,agent-handoffs,ai-memory,openclaw,claude-code,codex,opencode,memory,bootstrap,brigade,brigade-cli,operator,local-first,guardrails,agents-md
@@ -54,7 +54,7 @@ So I hand-rolled the fixes, one incident at a time: a slim `MEMORY.md` index poi
 
 Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that auto-promoted session fragments quietly bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Auto-promotion died that day. Everything goes through review now. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed quietly.
 
-That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/solomonneas/solos-cookbook) if you want to see where it came from.
+That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
 
 ## The loop
 

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/QUICKSTART.md

@@ -96,11 +96,11 @@ brigade reconfigure --target . --harnesses claude --prune
 
 The starter handoff template lives at `<inbox>/TEMPLATE.md`. Copy it to a new dated file (e.g. `2026-05-16-1430-fixed-X.md`), fill it in, and the ingester promotes safe card handoffs into `memory/cards/`, appends targeted updates to the right file, and kicks ambiguous material to the review inbox.
 
-See the [Solo Cookbook](https://github.com/solomonneas/solos-cookbook) for the longer-form guidance on what makes a good handoff and when to use which routing.
+See the [Solo Cookbook](https://github.com/escoffier-labs/solos-cookbook) for the longer-form guidance on what makes a good handoff and when to use which routing.
 
 ## Next steps
 
-- Read [the cookbook](https://github.com/solomonneas/solos-cookbook) for the deep version of every concept here.
+- Read [the cookbook](https://github.com/escoffier-labs/solos-cookbook) for the deep version of every concept here.
 - Customize `USER.md` and `TOOLS.md` with your real preferences and runbooks (kept private; do not commit personal details).
 - Wire the ingester on a cron or a manual end-of-day workflow.
 - Add a memory-care staleness scan when your card set starts to matter. See `memory/cards/memory-care-staleness.md`.

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/README.md

@@ -25,7 +25,7 @@ So I hand-rolled the fixes, one incident at a time: a slim `MEMORY.md` index poi
 
 Two incidents shaped the design more than anything I planned. First, a nightly "dreaming" job that auto-promoted session fragments quietly bloated `MEMORY.md` to 41KB, way past the 12KB bootstrap budget, so every session started with truncated memory and nobody noticed for weeks. Auto-promotion died that day. Everything goes through review now. Second, I found 195 handoff notes sitting unread across 35 repos because the ingester had a hardcoded three-repo allowlist and nothing warned about the coverage gap. Silence is the failure mode. Every part of Brigade that lints, warns, or writes a receipt exists because something once failed quietly.
 
-That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/solomonneas/solos-cookbook) if you want to see where it came from.
+That system now runs 482 memory cards and survives daily multi-agent work. But explaining it to anyone meant: clone six repos, write these crons, keep your index slim, watch for staleness, and whatever you do, turn auto-promotion off. Brigade is that setup packaged as one installable CLI. The full production stack is documented in the [solos-cookbook](https://github.com/escoffier-labs/solos-cookbook) if you want to see where it came from.
 
 ## The loop
 

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "brigade-cli"
-version = "0.9.2"
+version = "0.10.0"
 description = "AI agent memory, handoffs, and local guardrails for Codex, Claude Code, OpenCode, Hermes, and OpenClaw."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,9 +28,9 @@ research = ["playwright>=1.40"]
 [project.urls]
 Homepage = "https://brigade.tools"
 Repository = "https://github.com/escoffier-labs/brigade"
-Cookbook = "https://github.com/solomonneas/solos-cookbook"
+Cookbook = "https://github.com/escoffier-labs/solos-cookbook"
 OpenClaw = "https://github.com/solomonneas/openclaw"
-ContentGuard = "https://github.com/solomonneas/content-guard"
+ContentGuard = "https://github.com/escoffier-labs/content-guard"
 AgentPantry = "https://github.com/escoffier-labs/agentpantry"
 Issues = "https://github.com/escoffier-labs/brigade/issues"
 

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/__init__.py

@@ -1,3 +1,3 @@
 """Brigade: local operator-system CLI for agent workspaces."""
 
-__version__ = "0.9.2"
+__version__ = "0.10.0"

brigade_cli-0.10.0/src/brigade/actionqueue.py

@@ -0,0 +1,118 @@
+"""Shared primitives for the single-file action-queue lifecycle.
+
+These helpers were extracted from near-identical private copies behind
+`center actions` (center_cmd), `repos actions` (repos_cmd), and
+`repos release actions` (repos_cmd). Each station keeps its own paths,
+payload builders, write envelope, and output text; this module owns the
+store read, id-prefix lookup, status stamping, fingerprint-deduped merge,
+and the archive split/append.
+
+The phase-ledger queue in phases_cmd stays local: it stores one JSON file
+per action and stamps `reviewed_at`/`review_reason` instead of the
+`started_at`/`completed_at`/`deferred_at` lifecycle fields below.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .localio import read_json_dict
+
+
+def read_actions(path: Path) -> list[dict[str, Any]]:
+    """Read the "actions" list from a single-file store; [] when missing or invalid."""
+    payload = read_json_dict(path)
+    actions = payload.get("actions") if isinstance(payload, dict) else None
+    return [item for item in actions if isinstance(item, dict)] if isinstance(actions, list) else []
+
+
+def find_action(
+    actions: list[dict[str, Any]],
+    action_id: str,
+    *,
+    id_field: str,
+    label: str,
+) -> tuple[dict[str, Any] | None, str | None]:
+    """Find the unique action whose id_field value starts with action_id.
+
+    Returns (action, None) on a unique match, otherwise (None, error) where the
+    error is a "{label} not found" or "{label} id is ambiguous" message.
+    """
+    matches = [action for action in actions if str(action.get(id_field) or "").startswith(action_id)]
+    if not matches:
+        return None, f"{label} not found: {action_id}"
+    if len(matches) > 1:
+        return None, f"{label} id is ambiguous: {action_id}"
+    return matches[0], None
+
+
+def stamp_status(action: dict[str, Any], status: str, *, now: str, reason: str | None = None) -> None:
+    """Apply a lifecycle status transition in place with the shared timestamp fields."""
+    action["status"] = status
+    action["updated_at"] = now
+    if status == "active":
+        action["started_at"] = now
+    elif status == "done":
+        action["completed_at"] = now
+    elif status == "deferred":
+        action["deferred_at"] = now
+        action["defer_reason"] = reason or "deferred"
+
+
+def merge_planned(
+    existing: list[dict[str, Any]],
+    archived: list[dict[str, Any]],
+    planned: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Append planned actions with new source_fingerprint values to existing in place.
+
+    Fingerprints already present in existing or archived are skipped.
+    Returns (created, skipped).
+    """
+    fingerprints = {str(action.get("source_fingerprint")) for action in existing}
+    fingerprints.update(str(action.get("source_fingerprint")) for action in archived)
+    created: list[dict[str, Any]] = []
+    skipped: list[dict[str, Any]] = []
+    for action in planned:
+        if str(action.get("source_fingerprint")) in fingerprints:
+            skipped.append(action)
+            continue
+        created.append(action)
+        existing.append(action)
+        fingerprints.add(str(action.get("source_fingerprint")))
+    return created, skipped
+
+
+def split_archived_completed(
+    actions: list[dict[str, Any]],
+    *,
+    now: str,
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    """Split actions into (archived copies of done actions, remaining actions).
+
+    Done actions are copied with status "archived" and archived_at/updated_at
+    set to now; all other actions pass through unchanged.
+    """
+    archived: list[dict[str, Any]] = []
+    remaining: list[dict[str, Any]] = []
+    for action in actions:
+        if action.get("status") == "done":
+            archived_action = dict(action)
+            archived_action["status"] = "archived"
+            archived_action["archived_at"] = now
+            archived_action["updated_at"] = now
+            archived.append(archived_action)
+        else:
+            remaining.append(action)
+    return archived, remaining
+
+
+def append_archive(path: Path, actions: list[dict[str, Any]]) -> None:
+    """Append actions to a JSONL archive, creating parent directories; no-op when empty."""
+    if not actions:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a") as handle:
+        for action in actions:
+            handle.write(json.dumps(action, sort_keys=True) + "\n")

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/center_cmd.py

@@ -5,15 +5,15 @@ import html
 import hashlib
 import json
 import re
-import shutil
 import subprocess
 import sys
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 from uuid import uuid4
 
-from . import chat_cmd, context_cmd, handoff_cmd, learn_cmd, memory_cmd, notifications_cmd, pantry_cmd, phases_cmd, projects_cmd, release_cmd, repos_cmd, research_cmd, roadmap_cmd, security_cmd, tools_cmd, work_cmd
+from . import actionqueue, chat_cmd, context_cmd, handoff_cmd, learn_cmd, memory_cmd, notifications_cmd, pantry_cmd, phases_cmd, projects_cmd, release_cmd, repos_cmd, reportstore, research_cmd, roadmap_cmd, security_cmd, tools_cmd, work_cmd
+from .localio import read_json_dict as _read_json, read_jsonl_dicts as _read_jsonl, utc_now as _now, write_json as _write_json
 
 SCHEMA_VERSION = 1
 SCHEMA_MANIFEST_VERSION = 1
@@ -46,23 +46,6 @@ CENTER_REQUIRED_ITEM_FIELDS = {
 }
 
 
-def _read_json(path: Path) -> dict[str, Any] | None:
-    try:
-        payload = json.loads(path.read_text())
-    except (OSError, json.JSONDecodeError):
-        return None
-    return payload if isinstance(payload, dict) else None
-
-
-def _write_json(path: Path, payload: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
-
-
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
 def _parse_time(value: object) -> datetime | None:
     if not isinstance(value, str) or not value:
         return None
@@ -569,26 +552,6 @@ def _iter_json_files(root: Path, pattern: str) -> list[dict[str, Any]]:
     return items
 
 
-def _read_jsonl(path: Path) -> list[dict[str, Any]]:
-    if not path.is_file():
-        return []
-    records: list[dict[str, Any]] = []
-    try:
-        lines = path.read_text().splitlines()
-    except OSError:
-        return []
-    for line in lines:
-        if not line.strip():
-            continue
-        try:
-            payload = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(payload, dict):
-            records.append(payload)
-    return records
-
-
 def _actions_root(target: Path) -> Path:
     return target / ".brigade" / "center" / "actions"
 
@@ -602,13 +565,7 @@ def _actions_archive_path(target: Path) -> Path:
 
 
 def _read_actions(target: Path) -> list[dict[str, Any]]:
-    payload = _read_json(_actions_path(target))
-    if payload is None:
-        return []
-    actions = payload.get("actions")
-    if not isinstance(actions, list):
-        return []
-    return [item for item in actions if isinstance(item, dict)]
+    return actionqueue.read_actions(_actions_path(target))
 
 
 def _read_action_archive(target: Path) -> list[dict[str, Any]]:
@@ -626,13 +583,7 @@ def _write_actions(target: Path, actions: list[dict[str, Any]]) -> None:
 
 
 def _append_action_archive(target: Path, actions: list[dict[str, Any]]) -> None:
-    if not actions:
-        return
-    path = _actions_archive_path(target)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("a") as handle:
-        for action in actions:
-            handle.write(json.dumps(action, sort_keys=True) + "\n")
+    actionqueue.append_archive(_actions_archive_path(target), actions)
 
 
 def _activity(target: Path) -> list[dict[str, Any]]:
@@ -1065,22 +1016,6 @@ def _readiness_waivers_path(target: Path) -> Path:
     return _readiness_root(target) / "waivers.jsonl"
 
 
-def _read_jsonl(path: Path) -> list[dict[str, Any]]:
-    if not path.is_file():
-        return []
-    records: list[dict[str, Any]] = []
-    for line in path.read_text().splitlines():
-        if not line.strip():
-            continue
-        try:
-            item = json.loads(line)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(item, dict):
-            records.append(item)
-    return records
-
-
 def _write_jsonl(path: Path, records: list[dict[str, Any]]) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     with path.open("w") as handle:
@@ -1467,32 +1402,18 @@ def _report_diffs_root(target: Path) -> Path:
 
 
 def _report_json_path(path: Path) -> Path:
-    return path / "CENTER_EVIDENCE.json" if path.is_dir() else path
+    return reportstore.bundle_json_path(path, "CENTER_EVIDENCE.json")
 
 
 def _read_report(path: Path) -> dict[str, Any] | None:
-    payload = _read_json(_report_json_path(path))
-    if payload is not None:
-        payload.setdefault("path", str(_report_json_path(path).parent))
-    return payload
+    return reportstore.read_bundle(path, "CENTER_EVIDENCE.json")
 
 
 def _reports(target: Path, *, include_archived: bool = False) -> list[dict[str, Any]]:
     roots = [_reports_root(target)]
     if include_archived:
         roots.append(_reports_archive_root(target))
-    reports: list[dict[str, Any]] = []
-    for root in roots:
-        if not root.is_dir():
-            continue
-        for child in root.iterdir():
-            if child.name.endswith("archive") or not child.is_dir():
-                continue
-            payload = _read_report(child)
-            if payload is not None:
-                reports.append(payload)
-    reports.sort(key=lambda item: str(item.get("created_at") or item.get("report_id") or ""), reverse=True)
-    return reports
+    return reportstore.list_bundles(roots, _read_report, id_field="report_id", skip_child=lambda name: name.endswith("archive"))
 
 
 def latest_report(target: Path) -> dict[str, Any] | None:
@@ -1511,15 +1432,7 @@ def latest_report_diff(target: Path) -> dict[str, Any] | None:
 
 def _resolve_report(target: Path, report_id: str) -> tuple[dict[str, Any] | None, str | None]:
     reports = _reports(target, include_archived=True)
-    if report_id == "latest":
-        latest = latest_report(target)
-        return (latest, None) if latest else (None, "operator report not found: latest")
-    matches = [item for item in reports if str(item.get("report_id") or "").startswith(report_id)]
-    if not matches:
-        return None, f"operator report not found: {report_id}"
-    if len(matches) > 1:
-        return None, f"operator report id is ambiguous: {report_id}"
-    return matches[0], None
+    return reportstore.resolve_bundle(reports, report_id, id_field="report_id", label="operator report", latest=lambda: latest_report(target))
 
 
 def _receipt_references(payload: dict[str, Any]) -> list[str]:
@@ -1771,9 +1684,12 @@ def _report_html(markdown: str, payload: dict[str, Any]) -> str:
 
 def _write_report_bundle(report_dir: Path, payload: dict[str, Any]) -> None:
     markdown = _report_markdown(payload)
-    _write_json(report_dir / "CENTER_EVIDENCE.json", payload)
-    (report_dir / "OPERATOR_REPORT.md").write_text(markdown)
-    (report_dir / "OPERATOR_REPORT.html").write_text(_report_html(markdown, payload))
+    reportstore.write_bundle(
+        report_dir,
+        payload,
+        evidence_name="CENTER_EVIDENCE.json",
+        documents={"OPERATOR_REPORT.md": markdown, "OPERATOR_REPORT.html": _report_html(markdown, payload)},
+    )
 
 
 def report_health(target: Path) -> dict[str, Any]:
@@ -1937,12 +1853,10 @@ def report_archive(*, target: Path, report_id: str, json_output: bool = False) -
     if not source.is_dir():
         print(f"error: operator report path is missing: {source}", file=sys.stderr)
         return 2
-    destination = _reports_archive_root(target) / source.name
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    if destination.exists():
+    destination, moved = reportstore.move_bundle(source, _reports_archive_root(target))
+    if not moved:
         print(f"error: archived operator report already exists: {destination}", file=sys.stderr)
         return 2
-    shutil.move(str(source), str(destination))
     payload = {"schema_version": SCHEMA_VERSION, "target": str(target), "report_id": report.get("report_id"), "status": "archived", "archive_path": str(destination)}
     if json_output:
         print(json.dumps(payload, indent=2, sort_keys=True))
@@ -2221,7 +2135,7 @@ def report_closeout(
     json_output: bool = False,
 ) -> int:
     target = target.expanduser().resolve()
-    if status not in {"reviewed", "deferred", "superseded", "archived"}:
+    if status not in reportstore.CLOSEOUT_STATUSES:
         print("error: --status must be one of reviewed, deferred, superseded, archived", file=sys.stderr)
         return 2
     report, error = _resolve_report(target, report_id)
@@ -2246,9 +2160,7 @@ def report_closeout(
         "deferred_item_ids": deferred,
         "report_fingerprint": report.get("report_fingerprint") or _fingerprint_payload({"reviews": report.get("reviews"), "activity": report.get("activity")}),
     }
-    closeout_path = report_path / "CLOSEOUT.json"
-    payload["path"] = str(closeout_path)
-    _write_json(closeout_path, payload)
+    closeout_path = reportstore.write_closeout(report_path, payload)
     report["closeout"] = payload
     _write_json(report_path / "CENTER_EVIDENCE.json", report)
     if json_output:
@@ -2335,12 +2247,8 @@ def _planned_actions(report: dict[str, Any]) -> list[dict[str, Any]]:
 
 def _find_action(target: Path, action_id: str) -> tuple[list[dict[str, Any]], dict[str, Any] | None, str | None]:
     actions = _read_actions(target)
-    matches = [item for item in actions if str(item.get("action_id") or "").startswith(action_id)]
-    if not matches:
-        return actions, None, f"action not found: {action_id}"
-    if len(matches) > 1:
-        return actions, None, f"action id is ambiguous: {action_id}"
-    return actions, matches[0], None
+    action, error = actionqueue.find_action(actions, action_id, id_field="action_id", label="action")
+    return actions, action, error
 
 
 def _action_counts(actions: list[dict[str, Any]]) -> dict[str, int]:
@@ -2594,17 +2502,7 @@ def actions_build(*, target: Path, report_id: str = "latest", allow_unreviewed:
         return 2
     planned = _planned_actions(report)
     existing = _read_actions(target)
-    existing_fingerprints = {str(item.get("source_fingerprint")) for item in existing}
-    existing_fingerprints.update(str(item.get("source_fingerprint")) for item in _read_action_archive(target))
-    created: list[dict[str, Any]] = []
-    skipped: list[dict[str, Any]] = []
-    for action in planned:
-        if str(action.get("source_fingerprint")) in existing_fingerprints:
-            skipped.append(action)
-            continue
-        created.append(action)
-        existing.append(action)
-        existing_fingerprints.add(str(action.get("source_fingerprint")))
+    created, skipped = actionqueue.merge_planned(existing, _read_action_archive(target), planned)
     _write_actions(target, existing)
     payload = {
         "schema_version": SCHEMA_VERSION,
@@ -2697,16 +2595,7 @@ def _set_action_status(
     if action is None:
         print(f"error: {error}", file=sys.stderr)
         return 1 if error and "not found" in error else 2
-    now = _now().isoformat()
-    action["status"] = status
-    action["updated_at"] = now
-    if status == "active":
-        action["started_at"] = now
-    elif status == "done":
-        action["completed_at"] = now
-    elif status == "deferred":
-        action["deferred_at"] = now
-        action["defer_reason"] = reason or "deferred"
+    actionqueue.stamp_status(action, status, now=_now().isoformat(), reason=reason)
     _write_actions(target, actions)
     payload = {
         "schema_version": SCHEMA_VERSION,
@@ -2740,18 +2629,7 @@ def actions_defer(*, target: Path, action_id: str, reason: str, json_output: boo
 def actions_archive_completed(*, target: Path, json_output: bool = False) -> int:
     target = target.expanduser().resolve()
     actions = _read_actions(target)
-    now = _now().isoformat()
-    archived: list[dict[str, Any]] = []
-    remaining: list[dict[str, Any]] = []
-    for action in actions:
-        if action.get("status") == "done":
-            archived_action = dict(action)
-            archived_action["status"] = "archived"
-            archived_action["archived_at"] = now
-            archived_action["updated_at"] = now
-            archived.append(archived_action)
-        else:
-            remaining.append(action)
+    archived, remaining = actionqueue.split_archived_completed(actions, now=_now().isoformat())
     _write_actions(target, remaining)
     _append_action_archive(target, archived)
     payload = {

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/chat_cmd.py

@@ -12,6 +12,7 @@ from typing import Any
 from . import toml_compat as tomllib
 from .install import apply_gitignore
 from .selection import Selection
+from .localio import utc_now as _now
 
 CONFIG_REL_PATH = ".brigade/chat-surfaces.toml"
 OUTPUT_ROOT_REL_PATH = ".brigade/chat-memory-sweeps"
@@ -140,10 +141,6 @@ DEFAULT_SURFACES = (
 CONFIDENCE_RANK = {"high": 0, "medium": 1, "normal": 1, "low": 2}
 
 
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
 def _config_path(target: Path) -> Path:
     return target / CONFIG_REL_PATH
 

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/cli.py

@@ -1203,6 +1203,10 @@ def _build_parser() -> argparse.ArgumentParser:
     p_memory_care_plan_fixes = memory_care_sub.add_parser("plan-fixes", help="Plan safe memory-care metadata fixes without writing files.")
     p_memory_care_plan_fixes.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_memory_care_plan_fixes.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_memory_care_backfill = memory_care_sub.add_parser("backfill", help="Backfill missing reviewed/freshness card metadata from git history (dry-run by default).")
+    p_memory_care_backfill.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update.")
+    p_memory_care_backfill.add_argument("--apply", action="store_true", help="Write the derived metadata into card frontmatter and record a receipt.")
+    p_memory_care_backfill.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_memory_care_status = memory_care_sub.add_parser("status", help="Show local memory-care status.")
     p_memory_care_status.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_memory_care_status.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
@@ -2147,6 +2151,11 @@ def _build_parser() -> argparse.ArgumentParser:
     p_learn_import.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update.")
     p_learn_import.add_argument("--dry-run", action="store_true", help="Report without writing imports.")
     p_learn_import.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
+    p_learn_import_learnings = learn_sub.add_parser("import-learnings", help="Import structured .learnings/ markdown log entries into the work inbox.")
+    p_learn_import_learnings.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to update.")
+    p_learn_import_learnings.add_argument("--file", action="append", default=[], help="Override the .learnings file to read. May be repeated.")
+    p_learn_import_learnings.add_argument("--dry-run", action="store_true", help="Report without writing imports.")
+    p_learn_import_learnings.add_argument("--json", action="store_true", help="Print machine-readable JSON.")
     p_learn_skill_candidates = learn_sub.add_parser("skill-candidates", help="Find repeatable learning patterns that could become reviewed skills.")
     p_learn_skill_candidates.add_argument("--target", "-t", type=Path, default=Path("."), help="Repo or workspace to inspect.")
     p_learn_skill_candidates.add_argument("--min-count", type=int, default=2, help="Minimum repeated evidence count required.")
@@ -3876,6 +3885,8 @@ def main(argv=None) -> int:
             return learn_cmd.doctor(target=args.target, json_output=args.json)
         if args.learn_command == "import-issues":
             return learn_cmd.import_issues(target=args.target, dry_run=args.dry_run, json_output=args.json)
+        if args.learn_command == "import-learnings":
+            return learn_cmd.import_learnings(target=args.target, files=args.file or None, dry_run=args.dry_run, json_output=args.json)
         if args.learn_command == "skill-candidates":
             return learn_cmd.skill_candidates(target=args.target, min_count=args.min_count, source=args.source, json_output=args.json)
         if args.learn_command == "propose-skill":
@@ -4058,6 +4069,8 @@ def main(argv=None) -> int:
                 )
             if args.memory_care_command == "scan":
                 return memory_cmd.scan(target=args.target, json_output=args.json)
+            if args.memory_care_command == "backfill":
+                return memory_cmd.backfill(target=args.target, apply=args.apply, json_output=args.json)
             if args.memory_care_command == "plan-fixes":
                 return memory_cmd.plan_fixes(target=args.target, json_output=args.json)
             if args.memory_care_command == "status":

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/context_cmd.py

@@ -10,6 +10,7 @@ from typing import Any
 from uuid import uuid4
 
 from . import work_cmd
+from .localio import read_json_dict as _read_json, stable_hash as _stable_hash, utc_now as _now, write_json as _write_json
 
 OK = "ok"
 WARN = "warn"
@@ -19,10 +20,6 @@ SYNC_CONFIG_REL_PATH = ".brigade/context/sync-targets.json"
 CONTEXT_PACK_STALE_HOURS = 72
 
 
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
 def _context_root(target: Path) -> Path:
     return target / ".brigade" / "context"
 
@@ -43,26 +40,6 @@ def _sync_plans_root(target: Path) -> Path:
     return _context_root(target) / "sync-plans"
 
 
-def _write_json(path: Path, payload: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
-
-
-def _read_json(path: Path) -> dict[str, Any] | None:
-    try:
-        payload = json.loads(path.read_text())
-    except (OSError, json.JSONDecodeError):
-        return None
-    return payload if isinstance(payload, dict) else None
-
-
-def _stable_hash(value: object) -> str:
-    rendered = json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)
-    import hashlib
-
-    return hashlib.sha256(rendered.encode("utf-8")).hexdigest()[:16]
-
-
 def _parse_iso_datetime(value: object) -> datetime | None:
     if not isinstance(value, str) or not value.strip():
         return None

{brigade_cli-0.9.2 → brigade_cli-0.10.0}/src/brigade/daily_cmd.py

@@ -19,6 +19,7 @@ from typing import Any
 from uuid import uuid4
 
 from . import center_cmd, context_cmd, handoff_cmd, memory_cmd, notifications_cmd, phases_cmd, security_cmd, toml_compat as tomllib, tools_cmd, work_cmd
+from .localio import read_json_dict as _read_json, utc_now as _now, write_json as _write_json
 
 SCHEMA_VERSION = 1
 RUN_STATUSES = {"reviewed", "deferred", "blocked", "archived"}
@@ -51,10 +52,6 @@ class _DailyStatusSectionTimeout(Exception):
         self.label = label
 
 
-def _now() -> datetime:
-    return datetime.now(timezone.utc)
-
-
 def _daily_root(target: Path) -> Path:
     return target / ".brigade" / "daily"
 
@@ -210,19 +207,6 @@ def _hardening_phases() -> list[dict[str, Any]]:
     return phases
 
 
-def _read_json(path: Path) -> dict[str, Any] | None:
-    try:
-        payload = json.loads(path.read_text())
-    except (OSError, json.JSONDecodeError):
-        return None
-    return payload if isinstance(payload, dict) else None
-
-
-def _write_json(path: Path, payload: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
-
-
 def _schema(name: str) -> dict[str, Any]:
     return {
         "name": name,