chat-recall 0.6.4 → 0.6.6

package/hooks/chat_recall_guard_hook.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# chat-recall decision guard — fires before a tool call runs.
+#
+# Reads the harness's pre-execution payload on stdin, asks the decision register
+# whether this call reaches for something already ruled out, and prints the
+# answer in that harness's own dialect. Registered as:
+#
+#   Claude Code   PreToolUse            settings.json hooks
+#   Codex         PreToolUse            hooks.json / [hooks] in config.toml
+#   Antigravity   PreToolUse            .agents/hooks.json
+#   Cursor        beforeShellExecution  .cursor/hooks.json
+#
+# OpenCode uses a TypeScript plugin rather than a script; `chat-recall guard`
+# is the same entry point there.
+#
+# ── Silence is the correct failure mode ─────────────────────────────────────
+#
+# Every failure path exits 0 with no output, and this file never blocks. A guard
+# that errors is a guard that stops work it was never asked to judge, and the
+# first time it does that somebody removes it — after which it protects nothing.
+# The binary itself is written the same way.
+#
+# Env:
+#   CHAT_RECALL_BIN            path to the binary (default: from PATH)
+#   CHAT_RECALL_GUARD_HARNESS  claude | codex | agy | cursor | opencode
+#   CHAT_RECALL_GUARD=0        turn the guard off entirely
+#   CHAT_RECALL_GUARD_ENFORCE=1  block instead of warning (opt in; see below)
+
+set -uo pipefail
+
+# Off by request. Checked first so disabling costs nothing.
+if [[ "${CHAT_RECALL_GUARD:-1}" == "0" ]]; then exit 0; fi
+
+# stdin is the payload. Read it even when we are about to bail, or the harness
+# can see a broken pipe on a hook that was only meant to be quiet.
+INPUT="$(cat 2>/dev/null || true)"
+[[ -z "$INPUT" ]] && exit 0
+
+BIN="${CHAT_RECALL_BIN:-$(command -v chat-recall 2>/dev/null || true)}"
+if [[ -z "$BIN" ]] || [[ ! -x "$BIN" ]]; then exit 0; fi
+
+HARNESS="${CHAT_RECALL_GUARD_HARNESS:-claude}"
+
+ARGS=(guard --harness "$HARNESS")
+# Enforcement is opt-in and per machine. The default is a warning on every
+# harness, because a wrong block burns the user's turn while a wrong warning
+# costs a line of context — and only one of those gets the guard uninstalled.
+if [[ "${CHAT_RECALL_GUARD_ENFORCE:-0}" == "1" ]]; then ARGS+=(--enforce); fi
+
+# A hard ceiling on top of the binary's own timeout. This runs in front of every
+# tool call, so the worst case has to be bounded by something the harness can
+# rely on rather than by a network.
+printf '%s' "$INPUT" | timeout 8 "$BIN" "${ARGS[@]}" 2>/dev/null || true
+exit 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chat-recall",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/munhq/chat-recall.git"

package/skills/chat-recall/SKILL.md

@@ -29,7 +29,7 @@ All tools are MCP tools on the `chat-recall` server, named
 **Reads are safe to call proactively. Writes are not.** Everything below is a
 read except these, which change stored memory or state — treat each as an edit
 and apply the test in `chat-recall-memory` before calling one:
-`recall_kg_add`, `recall_kg_invalidate`, `recall_decision_record`,
+`recall_kg_add`, `recall_kg_invalidate`, `recall_decision_record`, `recall_decisions`,
 `recall_diary_write`, `recall_set`, `recall_task_create`, `recall_task_update`,
 `recall_task_comment`,
 `recall_task_policy`,
@@ -88,6 +88,7 @@ CLAUDE.md rule is additive and reversible, so take it; ask first before setting
 **Findings, ranked** — `recall_claude_suggestions` (every finding that becomes an agent-instruction change — the CLAUDE.md rules and skill installs — merged across account scope and every indexed project) and `recall_improvements` (everything else, most urgent first; `create_tasks: true` opens one team task per item). They split the same engines, so an item never appears in both. Neither needs the codeindex binary: without it you still get the account-level half.
 **What changed** — `recall_edits_timeline` (cross-tool edits), `recall_diff` (per-session diffs), `recall_commits` (did it actually land), `recall_markers` (where a session went sideways).
 **Durable memory / KG** — `recall_kg_query` / `recall_kg_add` / `recall_kg_invalidate` / `recall_kg_timeline` / `recall_kg_stats`, `recall_decision_record`, `recall_diary_write` / `recall_diary_read`, `recall_set` / `recall_get`.
+**Decisions** — `recall_decisions` (what is already settled per area, cascade resolved; call it before choosing a library or a datastore).
 **Team** — `recall_tasks` (the shared task board), `recall_task_create`, `recall_task_update` (status, assignee, linked session; task ids look like `t_…`; when you start work on a task, set it `in_progress` and pass your session id as `linked_session_id` so the board can verify the work shipped), `recall_task_comment` (leave a progress note on a card), `recall_task_policy` (read or change WHAT the board files — severity floor, open-card ceiling, cards per run, categories, and the projects that never file at all via `exclude_project` — reach for that one when the user says "do not put work on my board for this repo", e.g. a client's codebase they keep separate; call it with no arguments to read, and reach for it when the user says "only security", "high and critical for now", or asks why a full board has stopped filing), `recall_team_activity` (per-teammate × per-project rollup), `recall_shares` (which projects are shared — private by default, nothing is visible to teammates until shared).
 **Toolkit sync across tools and devices** — `recall_toolkit_status` (which MCP servers, skills, commands and agents exist, on which tool, on which device — and which of them can be installed elsewhere at all), `recall_toolkit_sync` (queue an install: everything or one type, every device or one machine, or fan a machine's own artifacts across its own tools). Reach for these on "set up my other laptop", "get my MCPs everywhere", "why does this tool not have my skill".
 

package/skills/chat-recall-memory/SKILL.md

@@ -26,11 +26,27 @@ future sessions inherit them.
 - `mcp__chat-recall__recall_diary_read` — prior agent diary entries (narrative
   notes across sessions). `mcp__chat-recall__recall_get` — a scoped key/value.
 
+## Check what is already decided (do this BEFORE you choose)
+
+- `mcp__chat-recall__recall_decisions` — the decision register, cascade already
+  resolved: one value per area (auth, database, payments, deploy, pricing,
+  licensing…), what it replaced and when, and the session behind it. Call it
+  before picking a library, a datastore or an auth method. If the area is
+  already decided, follow it or say plainly that you are proposing a reversal.
+  It also returns `gaps` — areas nobody has decided, where you are free to
+  choose and should record the choice afterwards.
+
+  Project overrides beat account-wide decisions. A personal preference is
+  returned marked `advisory` and never overrides a team decision.
+
 ## Record new knowledge (do this when something non-obvious is decided)
 
 - `mcp__chat-recall__recall_decision_record` — an explicit decision (subject,
-  decision, reason, importance). Shows up in future wake-up context. Use the
-  moment you and the user agree on something a later session would need.
+  decision, reason, importance). **Pass `area`**: it is the key a reversal
+  supersedes on, so recording a new `auth` decision closes the previous one and
+  leaves every other area alone. Without it nothing the decision contradicts is
+  closed. Shows up in future wake-up context. Use the moment you and the user
+  agree on something a later session would need.
 - `mcp__chat-recall__recall_kg_add` — assert a fact triple
   (subject → predicate → object, optional `valid_from`). E.g.
   `("chat-recall", "uses", "Postgres")`.