mishkan-harness 0.1.0

package/payload/mishkan/evals/baruch/README.md

@@ -0,0 +1,93 @@
+# Baruch eval
+
+A minimal, deterministic eval for the terminal stage of the research
+pipeline. It validates the schema enforcement around
+`research-log.json` and asserts the semantic shape of a known-good
+Baruch output for one scenario.
+
+The eval **does not** run Baruch live (that would require an LLM
+call). It is a contract eval: the schema, the validator, and a
+golden output are exercised end-to-end so that regressions in any
+of those layers are caught.
+
+## Layout
+
+```
+evals/baruch/
+├── README.md                ← this file
+├── run.sh                   ← runner (idempotent; exit 0 = all pass)
+├── fixtures/
+│   ├── valid/               ← known-good logs; validator MUST accept
+│   │   ├── resolved-cross-harness.json
+│   │   ├── curated-shortcircuit.json
+│   │   ├── partial-no-write.json
+│   │   └── blocked-vendor.json
+│   └── invalid/             ← each isolates one schema violation
+│       ├── missing-required-field.json
+│       ├── bad-trigger-enum.json
+│       ├── bad-outcome-enum.json
+│       ├── bad-sprint-pattern.json
+│       └── malformed-json.json
+└── golden_case/
+    ├── input.yaml           ← what Baruch receives (upstream context)
+    ├── expected.yaml        ← semantic assertions (jq filter: expected JSON)
+    └── produced.json        ← reference Baruch output for this input
+```
+
+## What the runner checks
+
+1. **Every valid fixture validates.** Catches schema or validator
+   over-strictness regressions.
+2. **Every invalid fixture is rejected.** Catches validator
+   under-strictness regressions (missing required-field check,
+   missing enum check, etc.).
+3. **The golden case satisfies the schema and the semantic
+   assertions in `expected.yaml`.** Catches regressions in Baruch's
+   reasoning shape — fields being transcribed verbatim, the
+   cross-harness write rule, faithful `tools_invoked` list, etc.
+
+## Running
+
+```bash
+./run.sh
+# 0 → all checks pass
+# 1 → one or more checks failed
+# 2 → environment problem (missing jq, validator, schema)
+```
+
+## Updating
+
+- **A new valid scenario.** Drop a fully-populated, valid log into
+  `fixtures/valid/`. The runner picks it up automatically.
+- **A new invalid scenario.** Drop a log with exactly one violation
+  into `fixtures/invalid/`. Isolating the violation is the
+  discipline — bundled invalid fixtures hide which check caught
+  what.
+- **A new golden scenario.** Add a sibling under `golden_case/` and
+  extend the runner, or refactor `golden_case/` into multiple
+  sub-cases. Each golden case has the
+  `input.yaml` + `expected.yaml` + `produced.json` triplet.
+- **Running Baruch live to refresh `produced.json`.** Re-run the
+  pipeline against `input.yaml`; copy the new output to
+  `produced.json`. Inspect the diff; if Baruch's reasoning shape
+  changed, update `expected.yaml` deliberately.
+
+## The expected.yaml format
+
+```
+<jq filter>: <expected JSON value>
+```
+
+- Lines starting with `#` are comments.
+- Blank lines are ignored.
+- The expected side is canonical JSON: `"string"`, `123`, `true`,
+  `false`, `null`, `[...]`, `{...}`. Bare words become strings.
+- The filter is anything jq accepts. Single-quoted strings inside
+  the filter are fine (jq accepts them; they avoid escaping in YAML).
+
+## See also
+
+- The schema: [`../../templates/research-log.schema.json`](../../templates/research-log.schema.json)
+- The validator: [`../../scripts/validate-research-log.sh`](../../scripts/validate-research-log.sh)
+- Baruch agent: [`../../agents/baruch.md`](../../agents/baruch.md)
+- Baruch craft skill: [`../../skills/baruch-research-reporting-craft/SKILL.md`](../../skills/baruch-research-reporting-craft/SKILL.md)

package/payload/mishkan/evals/baruch/fixtures/invalid/bad-outcome-enum.json

@@ -0,0 +1,15 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "asyncpg recovery question",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "summary",
+  "applied_to_task": "T-12",
+  "outcome": "maybe",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/invalid/bad-sprint-pattern.json

@@ -0,0 +1,15 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "sprint-2",
+  "trigger": "faced_problem",
+  "query_intent": "asyncpg recovery question",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "summary",
+  "applied_to_task": "T-12",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/invalid/bad-trigger-enum.json

@@ -0,0 +1,15 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "curious",
+  "query_intent": "asyncpg recovery question",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "summary",
+  "applied_to_task": "T-12",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/invalid/malformed-json.json

@@ -0,0 +1,7 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "faced_problem"
+  "query_intent": "missing comma above"
+}

package/payload/mishkan/evals/baruch/fixtures/invalid/missing-required-field.json

@@ -0,0 +1,14 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "asyncpg recovery question",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "applied_to_task": "T-12",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/valid/blocked-vendor.json

@@ -0,0 +1,15 @@
+{
+  "agent": "joab",
+  "team": "mishmar",
+  "sprint": "S2",
+  "trigger": "requested",
+  "query_intent": "Whether VendorX OAuth2 honours PKCE S256 in production, since public docs describe staging only.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "VendorX public OAuth2 docs describe staging behaviour and state production may differ. No authoritative source for production PKCE handling found; community reports conflict. Confidence: low. Cannot resolve without vendor confirmation.",
+  "applied_to_task": "T-24",
+  "outcome": "blocked",
+  "knowledge_graph_write": false,
+  "curated_library_match": false,
+  "cognee_node_id": null,
+  "timestamp": "2026-06-02T14:10:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/valid/curated-shortcircuit.json

@@ -0,0 +1,15 @@
+{
+  "agent": "salma",
+  "team": "panim",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "Whether TanStack Query v5 useQuery still exposes onSuccess and onError callbacks.",
+  "tools_invoked": ["jakin", "ezra", "baruch"],
+  "research_output_summary": "TanStack Query v5 removed onSuccess, onError, and onSettled from useQuery (Oct 2023). Migration: use useEffect keyed on data/error or a mutation observer pattern. Source: TanStack v5 migration guide.",
+  "applied_to_task": "T-19",
+  "outcome": "resolved",
+  "knowledge_graph_write": false,
+  "curated_library_match": true,
+  "cognee_node_id": null,
+  "timestamp": "2026-06-02T14:05:00Z"
+}

package/payload/mishkan/evals/baruch/fixtures/valid/partial-no-write.json

@@ -0,0 +1,14 @@
+{
+  "agent": "salma",
+  "team": "panim",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "Whether Next.js 15 App Router supports streaming + Server Actions + dynamic imports in combination, and what the documented interaction is.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "Streaming + Server Actions documented separately; dynamic imports under React 19 documented separately. Three-way combination not covered in v15 docs as of search date; vercel/examples #3104 shows it works but relies on cache-control choices. Confidence: medium. Gap: official documentation of combined behaviour.",
+  "applied_to_task": "T-22",
+  "outcome": "partial",
+  "knowledge_graph_write": false,
+  "curated_library_match": false,
+  "cognee_node_id": null
+}

package/payload/mishkan/evals/baruch/fixtures/valid/resolved-cross-harness.json

@@ -0,0 +1,15 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "How asyncpg handles connection loss mid-transaction; recovery semantics, observable error class, and whether the transaction is automatically retried.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "asyncpg raises InterfaceError or ConnectionDoesNotExistError on network loss mid-transaction. The transaction is NOT auto-retried; the pool acquires a fresh connection on next use. Application must catch and decide. Sources: magicstack/asyncpg docs and issue #847. Confidence: high.",
+  "applied_to_task": "T-12",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/golden_case/expected.yaml

@@ -0,0 +1,35 @@
+# Golden case expectations — semantic assertions on Baruch's output.
+#
+# Format: each non-blank, non-comment line is `<jq filter>: <expected JSON>`.
+# The expected side is canonical JSON (string, number, true, false, array).
+# Fields like timestamp and the exact cognee_node_id value are don't-care;
+# the structural and semantic claims below must hold.
+
+# Identity transcription (from input.yaml verbatim where applicable)
+.agent: "hizkiah"
+.team: "yasad"
+.sprint: "S2"
+.trigger: "faced_problem"
+.applied_to_task: "T-12"
+
+# Outcome carries Shemaiah's verdict verbatim
+.outcome: "resolved"
+
+# Cross-harness scope + resolved => cognee write
+.knowledge_graph_write: true
+.curated_library_match: false
+
+# When a node was written, cognee_node_id is a non-empty string
+.cognee_node_id | type: "string"
+.cognee_node_id | length > 0: true
+
+# Stages actually invoked are recorded faithfully (no over- or under-listing)
+.tools_invoked | sort: ["baruch","caleb","ezra","jakin","shaphan","shemaiah"]
+
+# query_intent carries Jakin's clarified intent (key phrase must survive)
+.query_intent | contains("asyncpg"): true
+.query_intent | contains("mid-transaction"): true
+
+# research_output_summary preserves the source attribution from Shaphan
+.research_output_summary | contains("InterfaceError"): true
+.research_output_summary | contains("asyncpg"): true

package/payload/mishkan/evals/baruch/golden_case/input.yaml

@@ -0,0 +1,47 @@
+# Golden case input — what Baruch receives as upstream context.
+#
+# Scenario: Hizkiah hit an asyncpg unknown; the pipeline ran all six
+# stages; Shemaiah resolved with high confidence; the learning is
+# cross-harness (every asyncpg-using project cares).
+#
+# This file documents the input Baruch would see. The eval does NOT
+# run Baruch live (that would require an LLM call); it asserts that
+# a Baruch output produced from this input passes the schema +
+# matches the semantic expectations in expected.yaml.
+
+calling_agent:
+  alias: hizkiah
+  team: yasad
+
+sprint: S2
+trigger: faced_problem
+applied_to_task: T-12
+
+jakin_clarified_intent: |
+  How asyncpg handles connection loss mid-transaction; recovery
+  semantics, observable error class, and whether the transaction
+  is automatically retried.
+
+ezra_brief:
+  curated_library_match: false
+
+shaphan_summary: |
+  asyncpg raises InterfaceError or ConnectionDoesNotExistError on
+  network loss mid-transaction. The transaction is NOT auto-retried;
+  the pool acquires a fresh connection on next use. Application must
+  catch and decide. Sources: magicstack/asyncpg docs and issue #847.
+  Confidence: high.
+
+shemaiah_verdict:
+  outcome: resolved
+  confidence: high
+  curated_library_agreement: not_covered
+  cross_harness_promotion_recommended: true
+
+stages_invoked_actually:
+  - jakin
+  - ezra
+  - caleb
+  - shaphan
+  - shemaiah
+  - baruch

package/payload/mishkan/evals/baruch/golden_case/produced.json

@@ -0,0 +1,15 @@
+{
+  "agent": "hizkiah",
+  "team": "yasad",
+  "sprint": "S2",
+  "trigger": "faced_problem",
+  "query_intent": "How asyncpg handles connection loss mid-transaction; recovery semantics, observable error class, and whether the transaction is automatically retried.",
+  "tools_invoked": ["jakin", "ezra", "caleb", "shaphan", "shemaiah", "baruch"],
+  "research_output_summary": "asyncpg raises InterfaceError or ConnectionDoesNotExistError on network loss mid-transaction. The transaction is NOT auto-retried; the pool acquires a fresh connection on next use. Application must catch and decide. Sources: magicstack/asyncpg docs and issue #847. Confidence: high.",
+  "applied_to_task": "T-12",
+  "outcome": "resolved",
+  "knowledge_graph_write": true,
+  "curated_library_match": false,
+  "cognee_node_id": "node_01HZ7K3X9Y00000000000000",
+  "timestamp": "2026-06-02T14:00:00Z"
+}

package/payload/mishkan/evals/baruch/run.sh

@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# evals/baruch/run.sh — exercise the Baruch contract end-to-end.
+#
+# Three checks, each independent:
+#   1. Every fixture under fixtures/valid/   must validate (exit 0).
+#   2. Every fixture under fixtures/invalid/ must fail validation (exit 1).
+#   3. The golden case's produced.json must validate AND satisfy every
+#      jq assertion in golden_case/expected.yaml.
+#
+# Exit codes:
+#   0  → all checks passed.
+#   1  → one or more checks failed.
+#   2  → environment problem (missing jq, missing validator, missing schema).
+#
+# This eval does NOT run Baruch live. It validates the contract and
+# the golden output. To exercise Baruch's reasoning, swap produced.json
+# for a fresh run's output and re-run.
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+VALIDATOR_CANDIDATES=(
+  "${MISHKAN_HOME:-$HOME/.claude/mishkan}/scripts/validate-research-log.sh"
+  "$HERE/../../scripts/validate-research-log.sh"
+)
+VALIDATOR=""
+for c in "${VALIDATOR_CANDIDATES[@]}"; do
+  if [[ -x "$c" ]]; then VALIDATOR="$c"; break; fi
+done
+if [[ -z "$VALIDATOR" ]]; then
+  echo "error: validate-research-log.sh not found in any known location" >&2
+  printf '  searched: %s\n' "${VALIDATOR_CANDIDATES[@]}" >&2
+  exit 2
+fi
+if ! command -v jq >/dev/null 2>&1; then
+  echo "error: jq is required" >&2
+  exit 2
+fi
+
+PASS=0
+FAIL=0
+SKIP=0
+
+pass() { printf "  ✓ %s\n" "$1"; PASS=$((PASS+1)); }
+fail() { printf "  ✗ %s — %s\n" "$1" "$2"; FAIL=$((FAIL+1)); }
+
+# --- Check 1: valid fixtures must validate -----------------------------
+echo "[1/3] Valid fixtures must validate (expect exit 0)"
+shopt -s nullglob
+valid_count=0
+for f in "$HERE/fixtures/valid"/*.json; do
+  valid_count=$((valid_count+1))
+  name="$(basename "$f")"
+  if out=$("$VALIDATOR" "$f" 2>&1); then
+    pass "$name"
+  else
+    fail "$name" "validator rejected a known-good fixture: $out"
+  fi
+done
+[[ $valid_count -eq 0 ]] && echo "  (no fixtures found)" && SKIP=$((SKIP+1))
+
+# --- Check 2: invalid fixtures must fail validation --------------------
+echo "[2/3] Invalid fixtures must fail validation (expect exit 1)"
+invalid_count=0
+for f in "$HERE/fixtures/invalid"/*.json; do
+  invalid_count=$((invalid_count+1))
+  name="$(basename "$f")"
+  out=$("$VALIDATOR" "$f" 2>&1)
+  rc=$?
+  if [[ $rc -eq 1 ]]; then
+    pass "$name (rejected as expected)"
+  elif [[ $rc -eq 0 ]]; then
+    fail "$name" "validator accepted a known-bad fixture"
+  else
+    fail "$name" "validator returned $rc (expected 1)"
+  fi
+done
+[[ $invalid_count -eq 0 ]] && echo "  (no fixtures found)" && SKIP=$((SKIP+1))
+
+# --- Check 3: golden case — schema valid + semantic assertions ---------
+echo "[3/3] Golden case must validate and satisfy semantic assertions"
+GC="$HERE/golden_case/produced.json"
+EXPECT="$HERE/golden_case/expected.yaml"
+
+if [[ ! -r "$GC" ]]; then
+  fail "golden_case/produced.json" "missing or unreadable"
+elif [[ ! -r "$EXPECT" ]]; then
+  fail "golden_case/expected.yaml" "missing or unreadable"
+else
+  if out=$("$VALIDATOR" "$GC" 2>&1); then
+    pass "produced.json passes schema validation"
+  else
+    fail "produced.json" "did not pass schema validation: $out"
+  fi
+
+  # Each non-blank, non-comment line in expected.yaml is `<jq filter>: <expected>`.
+  # The expected side is YAML-ish JSON (string, number, true, false, JSON array).
+  while IFS= read -r raw; do
+    line="${raw%%#*}"                                  # strip inline comments
+    line="$(echo "$line" | sed -e 's/[[:space:]]*$//')"
+    [[ -z "$line" ]] && continue
+    filter="$(echo "$line" | sed -E 's/:[[:space:]]*[^:]*$//')"
+    expected_raw="$(echo "$line" | sed -E 's/^.*:[[:space:]]*//')"
+    filter="${filter#\"}"; filter="${filter%\"}"
+
+    # Normalise expected_raw to canonical JSON for comparison.
+    if expected_json=$(echo "$expected_raw" | jq -c . 2>/dev/null); then
+      :
+    else
+      # bare word like `true` / `false` / unquoted string — wrap as JSON string
+      expected_json=$(jq -nc --arg v "$expected_raw" '$v')
+    fi
+
+    if actual_json=$(jq -c "$filter" "$GC" 2>/dev/null); then
+      if [[ "$actual_json" == "$expected_json" ]]; then
+        pass "assertion: $filter"
+      else
+        fail "assertion: $filter" "expected $expected_json, got $actual_json"
+      fi
+    else
+      fail "assertion: $filter" "jq filter errored"
+    fi
+  done < "$EXPECT"
+fi
+
+# --- Summary ----------------------------------------------------------
+echo
+echo "Summary: $PASS passed, $FAIL failed, $SKIP skipped sections"
+[[ $FAIL -eq 0 ]]

package/payload/mishkan/hooks/model-route.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""MISHKAN PreToolUse hook — make config/model-routing.yaml authoritative.
+
+Fires before the Task/Agent (subagent) tool runs. Reads the agent->tier map and
+injects the resolved `model` into the tool input, so the YAML — not each agent's
+frontmatter — is the single source of truth for which Claude tier a subagent
+runs on. Frontmatter `model:` becomes the fallback used only when this hook is
+absent.
+
+Fail-open by contract: any parse/IO/format problem => emit nothing and exit 0,
+so a broken config never blocks delegation. Only ever ADDS a `model` field.
+
+stdin  : Claude Code PreToolUse JSON {tool_name, tool_input, ...}
+stdout : {"hookSpecificOutput": {"hookEventName": "PreToolUse",
+                                  "permissionDecision": "allow",
+                                  "updatedInput": <tool_input + model>}}
+"""
+import json
+import os
+import sys
+
+VALID = {"opus", "sonnet", "haiku"}
+SUBAGENT_TOOLS = {"Task", "Agent"}
+YAML = os.path.join(os.path.dirname(__file__), "..", "config", "model-routing.yaml")
+
+
+def parse_routing(path):
+    """Minimal YAML reader for this file's shape (no external deps).
+
+    Captures `defaults.unlisted_agent` and the `agents:` name->tier map; strips
+    inline `# comments`. Returns (agents_map, default_tier).
+    """
+    agents, default = {}, "sonnet"
+    section = None
+    with open(path, "r") as fh:
+        for raw in fh:
+            line = raw.split("#", 1)[0].rstrip()
+            if not line.strip():
+                continue
+            if not line.startswith((" ", "\t")):           # top-level key
+                section = line.strip().rstrip(":")
+                continue
+            key, _, val = line.strip().partition(":")
+            key, val = key.strip(), val.strip()
+            if not val:
+                continue
+            if section == "defaults" and key == "unlisted_agent" and val in VALID:
+                default = val
+            elif section == "agents" and val in VALID:
+                agents[key] = val
+    return agents, default
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return  # not parseable input -> do nothing
+
+    tool = payload.get("tool_name", "")
+    tin = payload.get("tool_input")
+    if tool not in SUBAGENT_TOOLS or not isinstance(tin, dict):
+        return
+
+    subagent = tin.get("subagent_type")
+    if not subagent:
+        return  # generic/no-type agent call -> leave model to default mechanism
+
+    try:
+        agents, _default = parse_routing(YAML)
+    except Exception:
+        return  # missing/broken routing file -> fail open
+
+    # Authoritative ONLY for agents the YAML explicitly lists (the MISHKAN fleet).
+    # Foreign agents (e.g. aiobi-ops, Explore) keep their own frontmatter model —
+    # never downgrade them via an unlisted fallback.
+    if subagent not in agents:
+        return
+    model = agents[subagent]
+    if model not in VALID:
+        return
+
+    updated = dict(tin)
+    updated["model"] = model
+    print(json.dumps({
+        "hookSpecificOutput": {
+            "hookEventName": "PreToolUse",
+            "permissionDecision": "allow",
+            "permissionDecisionReason": f"MISHKAN model-routing: {subagent} -> {model}",
+            "updatedInput": updated,
+        }
+    }))
+
+
+if __name__ == "__main__":
+    main()

package/payload/mishkan/hooks/post-tool-observe.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# MISHKAN PostToolUse observability hook.
+# Emits one append-only JSON line per tool call into the session log.
+# Minimal: no parsing, no blocking. Token/cost enrichment happens later in the
+# observability aggregation step (Phase 8) which reads these raw lines.
+set -uo pipefail
+
+LOG_DIR="${HOME}/.claude/mishkan/logs"
+mkdir -p "$LOG_DIR"
+
+INPUT="$(cat)"
+
+if ! command -v jq >/dev/null 2>&1; then
+  # Fail open — never let observability break a tool call.
+  exit 0
+fi
+
+session="$(printf '%s' "$INPUT" | jq -r '.session_id // "unknown"' 2>/dev/null)"
+tool="$(printf '%s' "$INPUT" | jq -r '.tool_name // "unknown"' 2>/dev/null)"
+ts="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+# Outcome inferred from tool_response if present.
+outcome="$(printf '%s' "$INPUT" | jq -r '
+  if (.tool_response.error? // empty) != "" then "blocked" else "completed" end
+' 2>/dev/null)"
+[ -z "$outcome" ] && outcome="completed"
+
+# Append a raw event line. agent/team/sprint/tokens are enriched later from
+# session context; recorded here as null when the hook payload lacks them.
+jq -nc \
+  --arg session "$session" \
+  --arg tool "$tool" \
+  --arg outcome "$outcome" \
+  --arg ts "$ts" \
+  '{
+     session: $session,
+     tool_calls: [$tool],
+     outcome: $outcome,
+     timestamp: $ts,
+     agent: null, team: null, sprint: null,
+     tokens_input: 0, tokens_cached: 0, tokens_output: 0,
+     cost: 0, cognee_writes: 0
+   }' >> "${LOG_DIR}/${session}.jsonl" 2>/dev/null
+
+exit 0