fix: address tldraw review findings

Author: codejunkie99

.agent/AGENTS.md

@@ -41,6 +41,19 @@ are the exact failure mode this layer prevents.
 - Load a full `SKILL.md` only when its triggers match the current task
 - Every skill has a self-rewrite hook; invoke it after failures
 
+## Design Systems
+- If the project root contains `DESIGN.md`, treat it as the source of truth
+  for visual design decisions and load `skills/design-md/SKILL.md` when a
+  task mentions `DESIGN.md`, Google Stitch, design tokens, design system,
+  or visual design. (The skill's `preconditions` field gates loading on
+  `DESIGN.md` actually existing — keep this rule in lockstep with
+  `skills/_manifest.jsonl` to avoid same-task / different-harness drift.)
+- Prefer exact tokens, component rules, and design rationale from
+  `DESIGN.md` over invented colors, typography, spacing, shadows, or motion.
+- Do not modify `DESIGN.md` unless the user explicitly asks for a design
+  system change; implementation work consumes the contract, it doesn't
+  edit it.
+
 ## Protocols
 - `protocols/permissions.md` — read before any tool call
 - `protocols/tool_schemas/` — typed interfaces for external tools
@@ -55,6 +68,12 @@ Daily driver, highest-leverage first:
   in one shot (stage + graduate + render). For rules you already know.
 - `show.py` — one-screen dashboard of brain state: episodes, candidates,
   lessons, failing skills, activity graph.
+- `data_layer_export.py` — local cross-harness activity/data-layer export:
+  agent events, cron timelines, tokens/cost estimates, categories,
+  harness mix, `dashboard.html`, and `daily-report.md`.
+- `data_flywheel_export.py` — local export of approved, redacted runs into
+  trace records, context cards, eval cases, training-ready JSONL, and
+  flywheel metrics. It does not train models or call APIs.
 - `list_candidates.py` / `graduate.py` / `reject.py` / `reopen.py` — review
   protocol for patterns the dream cycle has staged.
 - `memory_reflect.py <skill> <action> <outcome>` — log a significant event.

.agent/harness/hooks/_episodic_io.py

@@ -0,0 +1,45 @@
+"""Cross-platform locked append for episodic JSONL writes.
+
+POSIX `write(2)` in O_APPEND mode is atomic for payloads up to PIPE_BUF
+(4 KB on Linux, 512 B minimum per POSIX). Most episodic entries fit,
+but failure entries with reflection + context + detail can exceed that,
+and two harness hooks writing from the same process (or from two Pi
+sessions on the same repo) can interleave bytes mid-line. Silent
+corruption is worse than a visible error because every downstream
+reader (`auto_dream.py`, `cluster.py`, `context_budget.py`,
+`show.py`) skips `JSONDecodeError` lines without surfacing the loss.
+
+This module serializes appends with `fcntl.flock(LOCK_EX)` on POSIX.
+On platforms without `fcntl` (native Windows Python) the lock is a
+no-op and behavior matches the pre-lock baseline. WSL, git-bash via
+Cygwin, macOS, and Linux all provide `fcntl`.
+"""
+import json
+import os
+
+try:
+    import fcntl  # POSIX
+    _HAVE_FLOCK = True
+except ImportError:
+    _HAVE_FLOCK = False
+
+
+def append_jsonl(path: str, entry: dict) -> dict:
+    """Serialize `entry` to one JSON line and append to `path`.
+
+    Uses `open(..., "ab")` (append-binary) to bypass Python's text-mode
+    buffering and guarantee a single `write(2)` per call. `fcntl.flock`
+    provides cross-process mutual exclusion on POSIX.
+    """
+    payload = (json.dumps(entry) + "\n").encode("utf-8")
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "ab") as f:
+        if _HAVE_FLOCK:
+            fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+        try:
+            f.write(payload)
+            f.flush()
+        finally:
+            if _HAVE_FLOCK:
+                fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+    return entry

.agent/harness/hooks/on_failure.py

@@ -1,6 +1,7 @@
 """Failures are learning. High pain score + rewrite flag after repeat offenses."""
 import json, datetime, os
 from ._provenance import build_source
+from ._episodic_io import append_jsonl
 
 ROOT = os.path.join(os.path.dirname(__file__), "..", "..")
 EPISODIC = os.path.join(ROOT, "memory/episodic/AGENT_LEARNINGS.jsonl")
@@ -11,7 +12,7 @@
 def _count_recent_failures(skill_name):
     if not os.path.exists(EPISODIC):
         return 0
-    cutoff = datetime.datetime.now() - datetime.timedelta(days=WINDOW_DAYS)
+    cutoff = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=WINDOW_DAYS)
     count = 0
     for line in open(EPISODIC):
         line = line.strip()
@@ -24,7 +25,10 @@ def _count_recent_failures(skill_name):
         if e.get("skill") != skill_name or e.get("result") != "failure":
             continue
         try:
-            if datetime.datetime.fromisoformat(e["timestamp"]) > cutoff:
+            ts = datetime.datetime.fromisoformat(e["timestamp"])
+            if ts.tzinfo is None:
+                ts = ts.replace(tzinfo=datetime.timezone.utc)
+            if ts > cutoff:
                 count += 1
         except (KeyError, ValueError):
             continue
@@ -47,7 +51,7 @@ def on_failure(skill_name, action, error, context="", confidence=0.9,
     # schema migration is recorded with its true importance and pain score;
     # the dream-cycle salience can't distinguish failure severity otherwise.
     entry = {
-        "timestamp": datetime.datetime.now().isoformat(),
+        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
         "skill": skill_name,
         "action": action[:200],
         "result": "failure",
@@ -69,7 +73,4 @@ def on_failure(skill_name, action, error, context="", confidence=0.9,
             f"Flag for rewrite."
         )
         entry["pain_score"] = 10
-    os.makedirs(os.path.dirname(EPISODIC), exist_ok=True)
-    with open(EPISODIC, "a") as f:
-        f.write(json.dumps(entry) + "\n")
-    return entry
+    return append_jsonl(EPISODIC, entry)

.agent/harness/hooks/pi_post_tool.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Process Pi Coding Agent tool_result events into episodic memory entries.
+
+Pi exposes a project-local extension system. The adapter installs
+`.pi/extensions/memory-hook.ts`, which forwards every `tool_result` event to
+this script via stdin. We normalize Pi's event shape into the same
+tool_input/tool_response structure used by the Claude Code hook so the
+importance scoring, reflection generation, and success classification stay
+consistent across harnesses.
+"""
+import json
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+AGENT_ROOT = os.path.abspath(os.path.join(HERE, "..", ".."))
+
+sys.path.insert(0, os.path.join(AGENT_ROOT, "harness"))
+sys.path.insert(0, os.path.join(AGENT_ROOT, "tools"))
+
+from hooks.post_execution import log_execution  # noqa: E402
+from hooks.on_failure import on_failure        # noqa: E402
+import hooks.claude_code_post_tool as cc       # noqa: E402
+
+
+_PI_TO_CANONICAL = {
+    "bash": "Bash",
+    "edit": "Edit",
+    "write": "Write",
+    "read": "Read",
+    "grep": "Grep",
+    "find": "Find",
+    "ls": "LS",
+    "task": "Task",
+    "todowrite": "TodoWrite",
+    "todo_write": "TodoWrite",
+    "webfetch": "WebFetch",
+    "web_fetch": "WebFetch",
+}
+
+# Pi tends to use camelCase for tool_input keys; the shared
+# claude_code_post_tool helpers (cc._action_label, cc._reflection,
+# cc._importance) expect the snake_case keys Claude Code sends.
+# Normalize a known set so action labels and reflections come out
+# meaningful instead of degrading to "edit: ?" / "Edited ?".
+_PI_INPUT_KEY_MAP = {
+    "filePath": "file_path",
+    "filepath": "file_path",
+    "path": "file_path",
+    "oldString": "old_string",
+    "oldstring": "old_string",
+    "newString": "new_string",
+    "newstring": "new_string",
+    "content": "content",
+    "command": "command",
+    "todos": "todos",
+    "todo": "todos",
+    "url": "url",
+    "pattern": "pattern",
+    "query": "query",
+}
+
+
+def _tool_name(name: str) -> str:
+    if not isinstance(name, str):
+        return "Unknown"
+    lowered = name.strip().lower()
+    if lowered in _PI_TO_CANONICAL:
+        return _PI_TO_CANONICAL[lowered]
+    if "_" in name:
+        return "".join(part[:1].upper() + part[1:] for part in name.split("_") if part)
+    return name[:1].upper() + name[1:]
+
+
+def _normalize_input(raw) -> dict:
+    """Map Pi tool_input keys to the snake_case shape cc.* helpers expect."""
+    if not isinstance(raw, dict):
+        if raw is None:
+            return {}
+        return {"raw": str(raw)}
+    out: dict = {}
+    for k, v in raw.items():
+        out[_PI_INPUT_KEY_MAP.get(k, k)] = v
+    return out
+
+
+def _extract_text(content) -> str:
+    if isinstance(content, str):
+        return content[:500]
+    if not isinstance(content, list):
+        return ""
+    texts = []
+    for item in content:
+        if isinstance(item, dict) and item.get("type") == "text":
+            text = item.get("text")
+            if isinstance(text, str) and text:
+                texts.append(text)
+    return " ".join(texts)[:500]
+
+
+def _normalize_response(event: dict) -> dict:
+    """Map Pi tool_result shape to the Claude hook's response schema."""
+    resp: dict = {"is_error": bool(event.get("isError", False))}
+    details = event.get("details")
+    content = event.get("content")
+
+    if isinstance(details, dict):
+        if isinstance(details.get("output"), str):
+            resp["output"] = details["output"][:500]
+        if isinstance(details.get("stdout"), str):
+            resp["stdout"] = details["stdout"][:500]
+        if isinstance(details.get("stderr"), str):
+            resp["stderr"] = details["stderr"][:300]
+        if isinstance(details.get("error"), str):
+            resp["error"] = details["error"][:300]
+        if isinstance(details.get("text"), str):
+            resp["text"] = details["text"][:500]
+        if "exitCode" in details:
+            resp["exit_code"] = details.get("exitCode")
+        if "cancelled" in details:
+            resp["interrupted"] = bool(details.get("cancelled"))
+        if "truncated" in details:
+            resp["truncated"] = bool(details.get("truncated"))
+        resp["details"] = details
+
+    text = _extract_text(content)
+    if text:
+        resp.setdefault("output", text)
+        resp["content"] = [{"type": "text", "text": text}]
+
+    if not any(k in resp for k in ("output", "stdout", "text", "content")):
+        if isinstance(details, str):
+            resp["output"] = details[:500]
+        elif details is not None:
+            resp["output"] = json.dumps(details, default=str)[:500]
+
+    return resp
+
+
+def _emit_malformed(reason: str, raw_excerpt: str) -> None:
+    """Record an explicit failure entry instead of silently logging a bogus
+    'Unknown success'. If Pi changes payload shape or sends malformed
+    JSON, this surfaces in AGENT_LEARNINGS.jsonl as a real signal.
+    """
+    excerpt = raw_excerpt[:200] if isinstance(raw_excerpt, str) else ""
+    # importance MUST be numeric — downstream salience_score() does
+    # `importance / 10.0` and a string would crash context_budget,
+    # show.py, and auto_dream readers. 5 ≈ "medium" on the 1-10 scale.
+    on_failure(
+        skill_name="pi",
+        action="hook:malformed_payload",
+        error=f"pi tool_result payload malformed: {reason}",
+        context=excerpt,
+        confidence=0.95,
+        importance=5,
+        pain_score=2,
+    )
+
+
+def main() -> None:
+    raw = ""
+    try:
+        raw = sys.stdin.read()
+    except OSError as e:
+        _emit_malformed(f"stdin read failed: {e}", "")
+        return
+
+    if not raw or not raw.strip():
+        _emit_malformed("empty payload", "")
+        return
+
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as e:
+        _emit_malformed(f"json decode error: {e.msg}", raw)
+        return
+
+    if not isinstance(payload, dict):
+        _emit_malformed(f"payload is {type(payload).__name__}, expected object", raw)
+        return
+
+    if "tool_name" not in payload:
+        _emit_malformed("missing tool_name", raw)
+        return
+
+    tool_name = _tool_name(payload.get("tool_name") or "Unknown")
+    tool_input = _normalize_input(payload.get("tool_input"))
+    tool_response = _normalize_response(payload)
+
+    success = cc._is_success(tool_name, tool_input, tool_response)
+    importance = cc._importance(tool_name, json.dumps(tool_input))
+    action = cc._action_label(tool_name, tool_input)
+    reflection = cc._reflection(tool_name, tool_input, tool_response, success)
+    detail = cc._detail(tool_name, tool_input, tool_response, success)
+
+    pscore = cc._pain_score(importance, success)
+    if success:
+        log_execution(
+            skill_name="pi",
+            action=action,
+            result=detail,
+            success=True,
+            reflection=reflection,
+            importance=importance,
+            confidence=0.7,
+            pain_score=pscore,
+        )
+    else:
+        on_failure(
+            skill_name="pi",
+            action=action,
+            error=reflection,
+            context=detail,
+            confidence=0.7,
+            importance=importance,
+            pain_score=pscore,
+        )
+
+
+if __name__ == "__main__":
+    main()

.agent/harness/hooks/post_execution.py

@@ -1,6 +1,7 @@
 """Runs after every action. Appends a structured entry to episodic memory."""
-import json, datetime, os
+import datetime, os
 from ._provenance import build_source
+from ._episodic_io import append_jsonl
 
 ROOT = os.path.join(os.path.dirname(__file__), "..", "..")
 EPISODIC = os.path.join(ROOT, "memory/episodic/AGENT_LEARNINGS.jsonl")
@@ -15,11 +16,10 @@ def log_execution(skill_name, action, result, success, reflection="",
     a higher value (e.g. 5) for high-importance successful operations so
     recurring patterns cross the dream-cycle promotion threshold (7.0).
     """
-    os.makedirs(os.path.dirname(EPISODIC), exist_ok=True)
     if pain_score is None:
         pain_score = 2 if success else 7
     entry = {
-        "timestamp": datetime.datetime.now().isoformat(),
+        "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
         "skill": skill_name,
         "action": action[:200],
         "result": "success" if success else "failure",
@@ -31,6 +31,4 @@ def log_execution(skill_name, action, result, success, reflection="",
         "source": build_source(skill_name),
         "evidence_ids": list(evidence_ids) if evidence_ids else [],
     }
-    with open(EPISODIC, "a") as f:
-        f.write(json.dumps(entry) + "\n")
-    return entry
+    return append_jsonl(EPISODIC, entry)

.agent/harness/salience.py

@@ -8,12 +8,17 @@ def salience_score(entry: dict) -> float:
     if not ts:
         return 0.0
     try:
-        age_days = (datetime.datetime.now()
-                    - datetime.datetime.fromisoformat(ts)).days
+        parsed = datetime.datetime.fromisoformat(ts)
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+        # Negative age can happen during the naive-→-UTC migration window
+        # if a legacy naive-local timestamp now reads as a few hours in the
+        # future. Floor at 0 so recency stays in [0, 10] instead of inflating.
+        age_days = max(0, (datetime.datetime.now(datetime.timezone.utc) - parsed).days)
     except ValueError:
         age_days = 999
     pain = entry.get("pain_score", 5)
     importance = entry.get("importance", 5)
     recurrence = entry.get("recurrence_count", 1)
-    recency = max(0.0, 10.0 - age_days * 0.3)
+    recency = max(0.0, min(10.0, 10.0 - age_days * 0.3))
     return recency * (pain / 10.0) * (importance / 10.0) * min(recurrence, 3)