Initial public threefold: tombstone + covenant + JLens (sample only)

Recreatable triad runner. No private memories. Lens fetched via script.

.gitignore

@@ -0,0 +1,25 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+venv/
+.env
+
+# Local data (private AI memory; never commit)
+data/ai_memory_root/
+data/
+
+# Large / generated artifacts
+*.pt
+runs/
+triad/runs/
+*.log
+
+# Vendor clone (optional local checkout of LAWLESS1987/covenant)
+vendor/covenant/
+
+# Editor / OS
+.DS_Store
+.idea/
+.vscode/

README.md

@@ -0,0 +1,103 @@
+# threefold
+
+**Tombstone ∥ Covenant ∥ JLens** — a mandatory three-leg memory/observability system for agent runs.
+
+Every completed task must fire **all three** legs under one shared `task_id`. There is no degrade path: if any leg fails, the triad fails.
+
+| Leg | What it is | Artifact |
+|-----|------------|----------|
+| **Tombstone** | Append-only public-facing run log | `tombstone/tombstone.md` |
+| **Covenant** | Private structured AI memories | `AI_MEMORY_ROOT` (default `./data/ai_memory_root`, gitignored) |
+| **JLens** | Real Anthropic `jlens.JacobianLens.apply` snapshot | `runs/<task_id>/jlens_snapshot.json` |
+
+Self-observation is **not** a triad leg.
+
+## Architecture
+
+```
+                    task_id (shared)
+                          │
+          ┌───────────────┼───────────────┐
+          ▼               ▼               ▼
+     tombstone.md    covenant puts    jlens snapshot
+     (append.sh)   (put_covenant_*)   (jlens_snapshot.py)
+          │               │               │
+          └───────────────┴───────────────┘
+                          │
+                   fire_triad.sh
+```
+
+`fire_triad.sh` runs **JLens first** so the digest can be stamped into tombstone notes and covenant bodies, then proves the same `task_id` appears in all three stores.
+
+## CPU notes
+
+- Model: `openai-community/gpt2` (~124M, 12 layers). Fits comfortably on CPU (~1GB peak RSS for the demo).
+- **No GPU required.** float32 CPU only.
+- Lens: pretrained gpt2-small weights from Hugging Face `neuronpedia/jacobian-lens`
+  (`gpt2-small/jlens/Salesforce-wikitext/gpt2_jacobian_lens.pt`), fetched by `scripts/fetch_lens.sh`.
+  The ~12MB `.pt` file is **not** shipped in this repo (size / GitHub limits).
+- Prefer Python **3.12**. Install **CPU** torch first.
+
+## Setup
+
+```bash
+git clone https://github.com/LAWLESS1987/threefold
+cd triad
+
+python3.12 -m venv .venv
+source .venv/bin/activate
+pip install --index-url https://download.pytorch.org/whl/cpu torch==2.14.1
+pip install -r requirements.txt
+pip install "jlens @ git+https://github.com/anthropics/jacobian-lens"
+
+# Covenant (private memory CLI) — do not vendor the whole tree into git history
+git clone https://github.com/LAWLESS1987/covenant vendor/covenant
+# or: export COVENANT_SRC=/path/to/covenant
+
+./scripts/fetch_lens.sh
+./scripts/seed_demo.sh          # MODE=apply (default): proves SUCCESS via demo_apply.py
+# MODE=triad ./scripts/seed_demo.sh   # full three-leg fire with fixed TASK_ID
+```
+
+Private memories default to `./data/ai_memory_root` (gitignored). Override with `AI_MEMORY_ROOT`.
+
+## How seed works
+
+`scripts/seed_demo.sh` uses fixed demo values:
+
+- `TASK_ID=20261007-020907-13423`
+- `PROMPT="Fact: The currency used in the country shaped like a boot is"`
+
+Default `MODE=apply` fetches the lens (if missing) and runs `demo_apply.py`, expecting the line:
+
+`SUCCESS: lens.apply returned real top-k tokens`
+
+`MODE=triad` additionally clones covenant if needed and runs `triad/fire_triad.sh`, expecting `FIRE_TRIAD_OK`.
+
+The sample entry in `tombstone/tombstone.md` is illustrative of that same `task_id` format only — no private history.
+
+## Layout
+
+```
+triad/
+  README.md
+  requirements.txt
+  .gitignore
+  jlens_snapshot.py
+  demo_apply.py
+  tombstone/
+    append.sh
+    tombstone.md          # SAMPLE only
+  triad/
+    fire_triad.sh
+    put_covenant_memory.sh
+  scripts/
+    fetch_lens.sh
+    seed_demo.sh
+```
+
+## License / upstream
+
+- Jacobian lens library: [anthropics/jacobian-lens](https://github.com/anthropics/jacobian-lens)
+- Pretrained lens weights: [neuronpedia/jacobian-lens](https://huggingface.co/neuronpedia/jacobian-lens)
+- Covenant memory CLI: [LAWLESS1987/covenant](https://github.com/LAWLESS1987/covenant)

demo_apply.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Prove jlens.JacobianLens.apply returns real top-k tokens on CPU.
+
+Model: openai-community/gpt2 (~124M)
+Lens:  pretrained gpt2-small lens (fetch via scripts/fetch_lens.sh)
+"""
+from __future__ import annotations
+
+import os
+import resource
+import time
+import traceback
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import torch
+import transformers
+import jlens
+
+MODEL_ID = "openai-community/gpt2"
+LENS_PATH = os.environ.get(
+    "JLENS_LENS",
+    os.path.join(os.path.dirname(os.path.abspath(__file__)), "gpt2_jacobian_lens.pt"),
+)
+PROMPT = os.environ.get(
+    "TRIAD_PROMPT",
+    "Fact: The currency used in the country shaped like a boot is",
+)
+TOP_K = 5
+
+
+def rss_mb() -> float:
+    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0
+
+
+def topk_tokens(logits: torch.Tensor, tok, k: int = TOP_K) -> list[str]:
+    ids = logits.topk(k).indices.tolist()
+    return [tok.decode([t]) for t in ids]
+
+
+def main() -> None:
+    t0 = time.perf_counter()
+    print("=== jlens CPU demo ===")
+    print(f"python torch={torch.__version__} cuda={torch.cuda.is_available()}")
+    print(f"transformers={transformers.__version__}")
+    print(f"jlens={jlens.__file__}")
+    print(f"model_id={MODEL_ID}")
+    print(f"lens=JacobianLens.load({LENS_PATH!r})")
+    print(f"rss_start_mb={rss_mb():.1f}")
+    print()
+
+    if not os.path.isfile(LENS_PATH):
+        raise SystemExit(
+            f"Missing lens at {LENS_PATH}. Run scripts/fetch_lens.sh first."
+        )
+
+    print("Loading model (CPU, float32)...")
+    t_load = time.perf_counter()
+    hf = transformers.AutoModelForCausalLM.from_pretrained(MODEL_ID)
+    hf.eval()
+    tok = transformers.AutoTokenizer.from_pretrained(MODEL_ID)
+    model = jlens.from_hf(hf, tok)
+    print(f"  model n_layers={model.n_layers} d_model={model.d_model}")
+    print(f"  load_s={time.perf_counter() - t_load:.1f} rss_mb={rss_mb():.1f}")
+    print()
+
+    print("Loading pre-fitted lens...")
+    t_lens = time.perf_counter()
+    lens = jlens.JacobianLens.load(LENS_PATH)
+    print(f"  {lens}")
+    print(f"  lens_load_s={time.perf_counter() - t_lens:.1f} rss_mb={rss_mb():.1f}")
+    print()
+
+    layers = [
+        model.n_layers // 4,
+        model.n_layers // 2,
+        (model.n_layers * 3) // 4,
+        model.n_layers - 2,
+    ]
+    layers = [L for L in layers if L in lens.jacobians]
+    if not layers:
+        layers = lens.source_layers[:: max(1, len(lens.source_layers) // 4)][:4]
+
+    print(f"prompt={PROMPT!r}")
+    print(f"layers={layers} positions=[-2]")
+    print()
+
+    t_apply = time.perf_counter()
+    lens_logits, model_logits, _ = lens.apply(
+        model, PROMPT, layers=layers, positions=[-2]
+    )
+    apply_s = time.perf_counter() - t_apply
+    print(f"apply_s={apply_s:.2f} rss_mb={rss_mb():.1f}")
+    print()
+
+    print("--- top-k from lens.apply (Jacobian lens) ---")
+    for layer in layers:
+        toks = topk_tokens(lens_logits[layer][0], tok)
+        print(f"L{layer:>3} J-lens top-{TOP_K}: {toks}")
+
+    print("--- model final logits top-k ---")
+    print(f"model top-{TOP_K}: {topk_tokens(model_logits[0], tok)}")
+    print()
+    print(f"TOTAL_s={time.perf_counter() - t0:.1f} peak_rss_mb={rss_mb():.1f}")
+    print("SUCCESS: lens.apply returned real top-k tokens")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        traceback.print_exc()
+        raise SystemExit(1)

jlens_snapshot.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Run real Anthropic jlens.JacobianLens.apply and write a triad snapshot.
+
+Usage:
+  jlens_snapshot.py --task-id TID --prompt "..." --out SNAPSHOT_PATH [--digest DIGEST_PATH]
+
+Exits nonzero if apply fails or top-k is empty.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+import time
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import torch
+import transformers
+import jlens
+
+MODEL_ID = "openai-community/gpt2"
+# Default: lens next to this script (after scripts/fetch_lens.sh)
+DEFAULT_LENS = os.path.join(os.path.dirname(os.path.abspath(__file__)), "gpt2_jacobian_lens.pt")
+TOP_K = 5
+
+
+def topk_tokens(logits: torch.Tensor, tok, k: int = TOP_K) -> list[str]:
+    ids = logits.topk(k).indices.tolist()
+    return [tok.decode([t]) for t in ids]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--task-id", required=True)
+    ap.add_argument("--prompt", required=True)
+    ap.add_argument("--out", required=True, help="JSON snapshot path")
+    ap.add_argument("--digest", default="", help="optional short digest text path")
+    ap.add_argument("--lens", default=DEFAULT_LENS)
+    ap.add_argument("--model", default=MODEL_ID)
+    args = ap.parse_args()
+
+    t0 = time.perf_counter()
+    hf = transformers.AutoModelForCausalLM.from_pretrained(args.model)
+    hf.eval()
+    tok = transformers.AutoTokenizer.from_pretrained(args.model)
+    model = jlens.from_hf(hf, tok)
+
+    lens = jlens.JacobianLens.load(args.lens)
+
+    layers = [
+        model.n_layers // 4,
+        model.n_layers // 2,
+        (model.n_layers * 3) // 4,
+        model.n_layers - 2,
+    ]
+    layers = [L for L in layers if L in lens.jacobians]
+    if not layers:
+        layers = list(lens.source_layers)[:4]
+
+    lens_logits, model_logits, _ = lens.apply(
+        model, args.prompt, layers=layers, positions=[-2]
+    )
+
+    per_layer = {}
+    lines = []
+    for layer in layers:
+        toks = topk_tokens(lens_logits[layer][0], tok)
+        if not toks:
+            print(f"ERROR: empty top-k at layer {layer}", file=sys.stderr)
+            return 1
+        per_layer[str(layer)] = toks
+        lines.append(f"L{layer}: {toks}")
+
+    model_top = topk_tokens(model_logits[0], tok)
+    body = {
+        "type": "jlens",
+        "task_id": args.task_id,
+        "model_id": args.model,
+        "lens_path": args.lens,
+        "prompt": args.prompt,
+        "layers": layers,
+        "positions": [-2],
+        "top_k": TOP_K,
+        "jlens_top_k": per_layer,
+        "model_final_top_k": model_top,
+        "apply_s": round(time.perf_counter() - t0, 3),
+        "mechanism": "anthropics/jacobian-lens JacobianLens.apply (real per-layer logits)",
+    }
+
+    os.makedirs(os.path.dirname(os.path.abspath(args.out)) or ".", exist_ok=True)
+    with open(args.out, "w", encoding="utf-8") as f:
+        json.dump(body, f, indent=2)
+        f.write("\n")
+
+    digest = (
+        f"jlens task_id={args.task_id} model={args.model} "
+        f"layers={layers} topk={{{'; '.join(lines)}}}"
+    )
+    digest_hash = hashlib.sha256(
+        json.dumps(body, sort_keys=True).encode()
+    ).hexdigest()[:16]
+    digest_line = f"{digest} digest={digest_hash}"
+
+    if args.digest:
+        with open(args.digest, "w", encoding="utf-8") as f:
+            f.write(digest_line + "\n")
+            for line in lines:
+                f.write(line + "\n")
+
+    print(digest_line)
+    for line in lines:
+        print(line)
+    print(f"SNAPSHOT_OK path={args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

requirements.txt

@@ -0,0 +1,12 @@
+# CPU-only triad demo stack (gpt2-small + pretrained Jacobian lens).
+# Prefer a Python 3.12 venv. Install torch CPU first, then the rest.
+#
+#   pip install --index-url https://download.pytorch.org/whl/cpu torch==2.14.1
+#   pip install -r requirements.txt
+#   pip install "jlens @ git+https://github.com/anthropics/jacobian-lens"
+#
+torch==2.14.1
+transformers==5.19.0
+huggingface_hub>=0.20.0
+# jlens: install from git (not on PyPI as a stable pin here)
+#   pip install "jlens @ git+https://github.com/anthropics/jacobian-lens"

scripts/fetch_lens.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Download the pretrained gpt2-small Jacobian lens from Hugging Face
+# (neuronpedia/jacobian-lens) into the repo root.
+#
+# Source path on the Hub:
+#   gpt2-small/jlens/Salesforce-wikitext/gpt2_jacobian_lens.pt
+#
+# Usage:
+#   ./scripts/fetch_lens.sh
+#   OUT=/path/to/gpt2_jacobian_lens.pt ./scripts/fetch_lens.sh
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+OUT="${OUT:-$REPO_ROOT/gpt2_jacobian_lens.pt}"
+REPO_ID="${HF_REPO_ID:-neuronpedia/jacobian-lens}"
+HF_PATH="${HF_LENS_PATH:-gpt2-small/jlens/Salesforce-wikitext/gpt2_jacobian_lens.pt}"
+
+if [[ -f "$OUT" ]]; then
+  echo "Lens already present: $OUT ($(du -h "$OUT" | awk '{print $1}'))"
+  exit 0
+fi
+
+echo "Fetching $REPO_ID / $HF_PATH -> $OUT"
+
+# Prefer huggingface-cli / huggingface_hub if available
+if command -v huggingface-cli >/dev/null 2>&1; then
+  TMPDIR="$(mktemp -d)"
+  huggingface-cli download "$REPO_ID" "$HF_PATH" --local-dir "$TMPDIR" --local-dir-use-symlinks False
+  mv "$TMPDIR/$HF_PATH" "$OUT"
+  rm -rf "$TMPDIR"
+elif python3 -c "import huggingface_hub" 2>/dev/null; then
+  python3 - <<PY
+from huggingface_hub import hf_hub_download
+import shutil, os
+path = hf_hub_download(repo_id="${REPO_ID}", filename="${HF_PATH}")
+shutil.copy2(path, "${OUT}")
+print(f"copied {path} -> ${OUT}")
+PY
+else
+  echo "Need huggingface_hub (pip install huggingface_hub) or huggingface-cli" >&2
+  exit 1
+fi
+
+ls -lh "$OUT"
+echo "FETCH_LENS_OK path=$OUT"

scripts/push_to_github.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_ROOT"
+OWNER=LAWLESS1987
+NAME=triad
+# Create if missing
+if ! gh repo view "$OWNER/$NAME" >/dev/null 2>&1; then
+  gh repo create "$OWNER/$NAME" --public --description "Mandatory three-leg agent memory: tombstone || covenant || JLens (shared task_id, no degrade)" --source . --remote origin --push
+else
+  git remote remove origin 2>/dev/null || true
+  git remote add origin "https://github.com/$OWNER/$NAME.git"
+  git push -u origin main
+fi
+echo "PUSH_OK https://github.com/$OWNER/$NAME"

scripts/seed_demo.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# Regenerate the public demo: fetch lens if missing, then either
+#   MODE=apply  (default) — run demo_apply.py and require SUCCESS
+#   MODE=triad            — run fire_triad.sh with fixed TASK_ID/PROMPT
+#
+# Fixed demo values (illustrative / reproducible enough to prove SUCCESS):
+#   TASK_ID=20261007-020907-13423
+#   PROMPT="Fact: The currency used in the country shaped like a boot is"
+#
+# Env overrides:
+#   JLENS_VENV  — python venv with torch/transformers/jlens
+#   MODE        — apply | triad
+#   COVENANT_SRC / AI_MEMORY_ROOT — for MODE=triad
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$REPO_ROOT"
+
+TASK_ID="${TASK_ID:-20261007-020907-13423}"
+PROMPT="${TRIAD_PROMPT:-Fact: The currency used in the country shaped like a boot is}"
+MODE="${MODE:-apply}"
+
+# Prefer explicit JLENS_VENV, then repo .venv, then common shared path
+if [[ -z "${JLENS_VENV:-}" ]]; then
+  if [[ -x "$REPO_ROOT/.venv/bin/python" ]]; then
+    JLENS_VENV="$REPO_ROOT/.venv"
+  elif [[ -x /workspace/jlens-venv/bin/python ]]; then
+    JLENS_VENV=/workspace/jlens-venv
+  else
+    JLENS_VENV="$REPO_ROOT/.venv"
+  fi
+fi
+export JLENS_VENV
+
+echo "=== seed_demo MODE=$MODE TASK_ID=$TASK_ID ==="
+echo "REPO_ROOT=$REPO_ROOT"
+echo "JLENS_VENV=$JLENS_VENV"
+
+# 1) Lens
+"$REPO_ROOT/scripts/fetch_lens.sh"
+export JLENS_LENS="${JLENS_LENS:-$REPO_ROOT/gpt2_jacobian_lens.pt}"
+
+# Resolve python
+if [[ -x "$JLENS_VENV/bin/python" ]]; then
+  PYTHON="$JLENS_VENV/bin/python"
+else
+  PYTHON="$(command -v python3)"
+fi
+echo "PYTHON=$PYTHON"
+
+if [[ "$MODE" == "apply" ]]; then
+  echo "--- demo_apply.py ---"
+  TRIAD_PROMPT="$PROMPT" JLENS_LENS="$JLENS_LENS" "$PYTHON" "$REPO_ROOT/demo_apply.py" | tee /tmp/triad_seed_demo_apply.log
+  rg -n "SUCCESS: lens.apply returned real top-k tokens" /tmp/triad_seed_demo_apply.log
+  echo "SEED_DEMO_OK mode=apply"
+  exit 0
+fi
+
+if [[ "$MODE" == "triad" ]]; then
+  # Ensure covenant is available
+  export COVENANT_SRC="${COVENANT_SRC:-$REPO_ROOT/vendor/covenant}"
+  if [[ ! -f "$COVENANT_SRC/ai_memory_system/main.py" ]]; then
+    echo "Cloning covenant into vendor/covenant ..."
+    mkdir -p "$REPO_ROOT/vendor"
+    git clone --depth 1 https://github.com/LAWLESS1987/covenant "$COVENANT_SRC"
+  fi
+  export AI_MEMORY_ROOT="${AI_MEMORY_ROOT:-$REPO_ROOT/data/ai_memory_root}"
+  mkdir -p "$AI_MEMORY_ROOT"
+
+  echo "--- fire_triad.sh ---"
+  export TASK_ID PROMPT JLENS_VENV JLENS_LENS
+  export JLENS_SNAPSHOT_PY="$REPO_ROOT/jlens_snapshot.py"
+  "$REPO_ROOT/triad/fire_triad.sh" \
+    "jlens-triad-e2e" \
+    "Prove real Anthropic jacobian-lens as triad third leg" \
+    "Installed gpt2 lens, wired fire_triad with tombstone+covenant+jlens.apply" \
+    "success" \
+    "$PROMPT" \
+    "none" \
+    "Third leg must be real jlens.apply not self-observation" \
+    "seed-demo" | tee /tmp/triad_seed_demo_triad.log
+  rg -n "FIRE_TRIAD_OK" /tmp/triad_seed_demo_triad.log
+  echo "SEED_DEMO_OK mode=triad task_id=$TASK_ID"
+  exit 0
+fi
+
+echo "Unknown MODE=$MODE (use apply|triad)" >&2
+exit 1

tombstone/append.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+# Append one tombstone entry. Usage:
+#   ./append.sh "short-title" "task" "done" "outcome" "mistakes" "lessons" ["notes"]
+# Or with env vars: TITLE TASK DONE OUTCOME MISTAKES LESSONS NOTES
+set -euo pipefail
+DIR="$(cd "$(dirname "$0")" && pwd)"
+LOG="${TOMBSTONE_LOG:-$DIR/tombstone.md}"
+
+TITLE="${1:-${TITLE:-}}"
+TASK="${2:-${TASK:-}}"
+DONE="${3:-${DONE:-}}"
+OUTCOME="${4:-${OUTCOME:-}}"
+MISTAKES="${5:-${MISTAKES:-none}}"
+LESSONS="${6:-${LESSONS:-none}}"
+NOTES="${7:-${NOTES:-}}"
+
+if [[ -z "$TITLE" || -z "$TASK" || -z "$DONE" || -z "$OUTCOME" ]]; then
+  echo "Usage: $0 \"short-title\" \"task\" \"done\" \"outcome\" [\"mistakes\"] [\"lessons\"] [\"notes\"]" >&2
+  echo "outcome must be one of: success | partial | failed | blocked" >&2
+  exit 1
+fi
+
+case "$OUTCOME" in
+  success|partial|failed|blocked) ;;
+  *) echo "Invalid outcome: $OUTCOME (use success|partial|failed|blocked)" >&2; exit 1 ;;
+esac
+
+TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+ID="$(date -u +%Y%m%d-%H%M%S)"
+
+{
+  echo ""
+  echo "### ${TS} | ${TITLE}"
+  echo "- id: ${ID}"
+  echo "- task: ${TASK}"
+  echo "- done: ${DONE}"
+  echo "- outcome: ${OUTCOME}"
+  echo "- mistakes: ${MISTAKES}"
+  echo "- lessons: ${LESSONS}"
+  if [[ -n "$NOTES" ]]; then
+    echo "- notes: ${NOTES}"
+  else
+    echo "- notes: none"
+  fi
+} >> "$LOG"
+
+echo "Appended entry ${ID} to $LOG"

tombstone/tombstone.md

@@ -0,0 +1,16 @@
+# Tombstone log (SAMPLE)
+
+Public sample only. Real deployments append locally; do not commit private entries.
+
+Format: each entry is a markdown subsection with `id`, `task`, `done`, `outcome`,
+`mistakes`, `lessons`, and `notes`. Triad runs stamp `task_id=...` and
+`jlens_digest=...` into notes so the three legs share one id.
+
+### 2026-10-07T02:09:13Z | jlens-triad-e2e
+- id: 20261007-020913
+- task: Prove real Anthropic jacobian-lens as triad third leg
+- done: Installed gpt2 lens, wired fire_triad with tombstone+covenant+jlens.apply
+- outcome: success
+- mistakes: none
+- lessons: Third leg must be real jlens.apply not self-observation
+- notes: task_id=20261007-020907-13423; jlens_digest=jlens task_id=20261007-020907-13423 model=openai-community/gpt2 layers=[3, 6, 9, 10] topk={L3: [' boot', 'boot', 'Boot', ' Boot', ' boots']; L6: ['boot', ' boot', 'Boot', ' Boot', ' boots']; L9: ['strap', 'loader', 'boot', 'legged', ' boot']; L10: ['strap', 'stra', 'legged', 'loader', 'leg']} digest=82a9a0b5be4cfbaa; sample-demo-entry

triad/fire_triad.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# fire_triad.sh — mandatory three-leg triad (tombstone + covenant + real JLens)
+#
+# Usage:
+#   ./fire_triad.sh TITLE TASK DONE OUTCOME PROMPT [MISTAKES] [LESSONS] [NOTES]
+# Or env: TITLE TASK DONE OUTCOME PROMPT MISTAKES LESSONS NOTES TASK_ID
+#
+# Legs (all required; any failure => exit nonzero):
+#   (a) tombstone append with JLens digest in notes
+#   (b) covenant puts (task-{id} + jlens-{id} type:jlens snapshot)
+#   (c) real Anthropic jlens.JacobianLens.apply snapshot
+#
+# Defaults resolve relative to REPO_ROOT (parent of triad/).
+set -euo pipefail
+
+DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$DIR/.." && pwd)"
+TOMBSTONE_APPEND="${TOMBSTONE_APPEND:-$REPO_ROOT/tombstone/append.sh}"
+PUT_COVENANT="${PUT_COVENANT:-$DIR/put_covenant_memory.sh}"
+JLENS_VENV="${JLENS_VENV:-${REPO_ROOT}/.venv}"
+# Prefer repo-local scripts; allow override for shared venvs.
+JLENS_SNAPSHOT_PY="${JLENS_SNAPSHOT_PY:-$REPO_ROOT/jlens_snapshot.py}"
+JLENS_LENS="${JLENS_LENS:-$REPO_ROOT/gpt2_jacobian_lens.pt}"
+RUN_DIR="${RUN_DIR:-$REPO_ROOT/runs}"
+export AI_MEMORY_ROOT="${AI_MEMORY_ROOT:-$REPO_ROOT/data/ai_memory_root}"
+export COVENANT_SRC="${COVENANT_SRC:-$REPO_ROOT/vendor/covenant}"
+
+TITLE="${1:-${TITLE:-}}"
+TASK="${2:-${TASK:-}}"
+DONE="${3:-${DONE:-}}"
+OUTCOME="${4:-${OUTCOME:-}}"
+PROMPT="${5:-${PROMPT:-}}"
+MISTAKES="${6:-${MISTAKES:-none}}"
+LESSONS="${7:-${LESSONS:-none}}"
+NOTES="${8:-${NOTES:-}}"
+
+if [[ -z "$TITLE" || -z "$TASK" || -z "$DONE" || -z "$OUTCOME" || -z "$PROMPT" ]]; then
+  echo "Usage: $0 TITLE TASK DONE OUTCOME PROMPT [MISTAKES] [LESSONS] [NOTES]" >&2
+  exit 1
+fi
+
+TASK_ID="${TASK_ID:-$(date -u +%Y%m%d-%H%M%S)-$$}"
+SNAP_DIR="$RUN_DIR/$TASK_ID"
+mkdir -p "$SNAP_DIR"
+SNAP_JSON="$SNAP_DIR/jlens_snapshot.json"
+SNAP_DIGEST="$SNAP_DIR/jlens_digest.txt"
+
+echo "=== fire_triad task_id=$TASK_ID ==="
+echo "prompt=$PROMPT"
+echo "REPO_ROOT=$REPO_ROOT"
+
+# Resolve python: JLENS_VENV, else python3 on PATH
+if [[ -x "$JLENS_VENV/bin/python" ]]; then
+  PYTHON="$JLENS_VENV/bin/python"
+elif command -v python3 >/dev/null 2>&1; then
+  PYTHON="$(command -v python3)"
+else
+  echo "No Python found (set JLENS_VENV or install python3)" >&2
+  exit 1
+fi
+
+# --- Leg (c) FIRST so digest can go into tombstone notes ---
+echo "--- leg c: JLens apply ---"
+if [[ ! -f "$JLENS_SNAPSHOT_PY" ]]; then
+  echo "Missing jlens_snapshot.py at $JLENS_SNAPSHOT_PY" >&2
+  exit 1
+fi
+if [[ ! -f "$JLENS_LENS" ]]; then
+  echo "Missing lens weights at $JLENS_LENS" >&2
+  echo "Run: scripts/fetch_lens.sh" >&2
+  exit 1
+fi
+
+"$PYTHON" "$JLENS_SNAPSHOT_PY" \
+  --task-id "$TASK_ID" \
+  --prompt "$PROMPT" \
+  --out "$SNAP_JSON" \
+  --digest "$SNAP_DIGEST" \
+  --lens "$JLENS_LENS"
+JLENS_DIGEST="$(head -1 "$SNAP_DIGEST")"
+JLENS_BODY="$(cat "$SNAP_JSON")"
+
+# --- Leg (a) tombstone with JLens digest in notes ---
+echo "--- leg a: tombstone ---"
+if [[ ! -x "$TOMBSTONE_APPEND" ]]; then
+  echo "Missing tombstone append at $TOMBSTONE_APPEND" >&2
+  exit 1
+fi
+COMBINED_NOTES="task_id=${TASK_ID}; jlens_digest=${JLENS_DIGEST}"
+if [[ -n "$NOTES" ]]; then
+  COMBINED_NOTES="${COMBINED_NOTES}; ${NOTES}"
+fi
+"$TOMBSTONE_APPEND" "$TITLE" "$TASK" "$DONE" "$OUTCOME" "$MISTAKES" "$LESSONS" "$COMBINED_NOTES"
+
+# --- Leg (b) covenant puts ---
+echo "--- leg b: covenant ---"
+if [[ ! -x "$PUT_COVENANT" ]]; then
+  echo "Missing put_covenant_memory.sh at $PUT_COVENANT" >&2
+  exit 1
+fi
+TASK_BODY="task_id=${TASK_ID}
+title=${TITLE}
+task=${TASK}
+done=${DONE}
+outcome=${OUTCOME}
+prompt=${PROMPT}
+jlens_digest=${JLENS_DIGEST}
+"
+JLENS_BODY="$JLENS_BODY" "$PUT_COVENANT" "$TASK_ID" "$TASK_BODY" \
+  "triad task memory for ${TASK_ID}"
+
+# Proof: all three legs share task_id
+echo "=== triad proof ==="
+echo "task_id=$TASK_ID"
+echo "jlens_snapshot=$SNAP_JSON"
+rg -n --fixed-strings "$TASK_ID" "$REPO_ROOT/tombstone/tombstone.md" | tail -5 || {
+  echo "PROOF FAIL: task_id not in tombstone" >&2
+  exit 1
+}
+rg -n --fixed-strings "$TASK_ID" "$AI_MEMORY_ROOT" -g '*.md' | head -20 || {
+  echo "PROOF FAIL: task_id not in covenant memories" >&2
+  exit 1
+}
+rg -n --fixed-strings "$TASK_ID" "$SNAP_JSON" || {
+  echo "PROOF FAIL: task_id not in jlens snapshot" >&2
+  exit 1
+}
+echo "FIRE_TRIAD_OK task_id=$TASK_ID (tombstone + covenant + real jlens.apply)"

triad/put_covenant_memory.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# Put covenant memories into the PRIVATE AI_MEMORY_ROOT.
+# Never writes into vendor/covenant. Memories stay outside the public clone.
+#
+# Usage:
+#   ./put_covenant_memory.sh TASK_ID BODY [DESCRIPTION]
+# Env:
+#   AI_MEMORY_ROOT, COVENANT_SRC, AGENT_NAME, MEMORY_TYPE
+#   JLENS_BODY — if set, also writes jlens-{TASK_ID} (type:jlens snapshot)
+#                CLI enum only allows user|feedback|project|reference;
+#                we use --type project and stamp type:jlens in body+description.
+set -euo pipefail
+DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$DIR/.." && pwd)"
+
+# Prefer COVENANT_SRC; else vendor/covenant under repo root.
+COVENANT_SRC="${COVENANT_SRC:-$REPO_ROOT/vendor/covenant}"
+MAIN="$COVENANT_SRC/ai_memory_system/main.py"
+export AI_MEMORY_ROOT="${AI_MEMORY_ROOT:-$REPO_ROOT/data/ai_memory_root}"
+AGENT_NAME="${AGENT_NAME:-grok-bot}"
+MEMORY_TYPE="${MEMORY_TYPE:-project}"
+
+TASK_ID="${1:-${TASK_ID:-}}"
+BODY="${2:-${BODY:-${DECISION_BODY:-}}}"
+DESCRIPTION="${3:-${DESCRIPTION:-triad decision for ${TASK_ID:-}}}"
+
+if [[ -z "$TASK_ID" || -z "$BODY" ]]; then
+  echo "Usage: $0 TASK_ID BODY [DESCRIPTION]" >&2
+  exit 1
+fi
+
+if [[ ! -f "$MAIN" ]]; then
+  echo "Covenant main.py not found at $MAIN" >&2
+  echo "Clone it: git clone https://github.com/LAWLESS1987/covenant \"$REPO_ROOT/vendor/covenant\"" >&2
+  echo "Or set COVENANT_SRC to an existing checkout." >&2
+  exit 1
+fi
+
+mkdir -p "$AI_MEMORY_ROOT"
+
+safe_name() { printf '%s' "$1" | tr -c 'A-Za-z0-9._-' '-'; }
+
+MEM_NAME="$(safe_name "task-${TASK_ID}")"
+
+echo "AI_MEMORY_ROOT=$AI_MEMORY_ROOT"
+python3 "$MAIN" --root "$AI_MEMORY_ROOT" put "$MEM_NAME" \
+  --description "$DESCRIPTION" \
+  --type "$MEMORY_TYPE" \
+  --body "$BODY" \
+  --agent "$AGENT_NAME"
+
+if [[ -n "${JLENS_BODY:-}" ]]; then
+  JLENS_NAME="$(safe_name "jlens-${TASK_ID}")"
+  # Real CLI type enum has no 'jlens'; stamp type:jlens in description+body.
+  python3 "$MAIN" --root "$AI_MEMORY_ROOT" put "$JLENS_NAME" \
+    --description "type:jlens full Jacobian-lens snapshot for ${TASK_ID}" \
+    --type project \
+    --body "$JLENS_BODY" \
+    --agent "$AGENT_NAME"
+  echo "Wrote covenant memories: $MEM_NAME and $JLENS_NAME under $AI_MEMORY_ROOT"
+else
+  echo "Wrote covenant memory: $MEM_NAME under $AI_MEMORY_ROOT"
+fi

vendor/README.md

@@ -0,0 +1,9 @@
+# vendor/
+
+Clone covenant here (not committed):
+
+```bash
+git clone https://github.com/LAWLESS1987/covenant vendor/covenant
+```
+
+Or set `COVENANT_SRC` to an existing checkout. The `vendor/covenant/` tree is gitignored.