tetra-scar

Scar memory, reflex arc, and decision traces for AI agents. Learn from failures permanently. Block repeated mistakes instantly — no LLM calls needed. Three-l...

Security Scan

The code and instructions mostly match a scar/reflex-memory tool, but provenance and packaging inconsistencies (references to missing modules/repos and mixed author IDs) and example CI integrations that call external scripts make the bundle unclear and worth manual review before use.

Purpose & Capability

The name/description (scar memory + reflex arc, block repeated mistakes) align with the included code (tetra_scar.py implements scars, reflex_check, tetra_check, JSONL storage). However several files reference different owners/names (README/action.yml mention aibenyclaude-coder, SKILL.md/README mention B Button Corp/b-button-corp) and examples refer to external packages (tetra-scar-code-review, scar_safety) that are not in this bundle. This provenance/packaging mismatch is unexpected.

Instruction Scope

SKILL.md and tetra_scar.py keep behavior local (read/write JSONL in memory dir, pattern matching, no network calls or secrets). But example CI and incident-response scripts attempt to call or import external scripts (../../tetra-scar-code-review/scar_code_review.py, scar_safety from ../tetra-scar-safety). The CI example records scars based on findings and will run external review scripts; those referenced scripts are not present here, so running examples may execute unknown code if the user wires them to other repos. Also scar_audit.py can clone arbitrary repos (it runs git clone) when used with --repo, which will fetch and execute analysis on remote code — expected for an audit tool but worth noting.

Install Mechanism

No install spec is declared (instruction-only). The package is distributed as source files only; there is no automated download of third‑party binaries or archives. This is lower risk, but examples/README suggest optional copying of tetra_scar.py into projects or using a separate action name which could lead users to fetch code from different owners.

Credentials

The skill does not request environment variables or credentials. Action.yml and CI examples use standard GitHub Actions environment variables (GITHUB_*), which is expected. There are no REQUIRED secret env vars in the skill metadata.

Persistence & Privilege

always is false and the skill writes only to local JSONL files under a configurable memory directory. That persistent storage is consistent with the described scar memory function and does not request system-wide privileges or modify other skills' configs.

What to consider before installing

This package implements a local scar/reflex memory and the code mostly matches that purpose — it stores JSONL scars, does pattern matching, and offers a 4-axis check. Before installing or enabling it, check/consider: - Provenance: files reference multiple authors/owners (b-button-corp, aibenyclaude-coder, and the anonymous owner ID). Verify the repository origin and prefer code from a trusted source. - Missing referenced components: examples and CI scripts call or import external scripts (tetra-scar-code-review/scar_code_review.py, scar_safety, tetra-scar-safety) that are not included. If you run those examples or wire the action as-is, you may end up executing external code—locate and inspect those referenced projects first. - Remote clone behavior: scar_audit.py can clone arbitrary GitHub repos when used with --repo. Cloning itself is expected for an audit tool, but avoid running the script on untrusted repos or in privileged CI runners without review. - Local persistence: scars are append-only JSONL files written to disk. Confirm the memory_dir path is acceptable and not pointing to sensitive locations. If you plan to use this skill: run the included tests locally (pytest), inspect the referenced external scripts before using the CI examples, and verify the action's owner/URL if you use it in CI. The inconsistencies suggest sloppy packaging rather than overt maliciousness, but manual review is recommended before trusting it in production.

What this does

Your agent keeps making the same mistakes. tetra-scar gives it a scar layer — immutable records of past failures that are checked before every action, without calling the LLM.

Two-layer memory:

• Scar layer (immutable): "What broke and what must never happen again." Cannot be deleted.
• Narrative layer (mutable): "What was done and who benefited." Overwritable.

Plus a reflex arc — pattern-matching against scars that fires before the LLM even sees the task. If a proposed action matches a past failure pattern, it's blocked instantly.

Quick start

After any failure, record a scar:

python3 tetra_scar.py scar-add \
  --what-broke "Deployed to production without running tests" \
  --never-again "Always run full test suite before any deployment"

Before any action, check the reflex:

python3 tetra_scar.py reflex-check --task "Deploy latest changes to production"
# Output: BLOCKED — scar collision: "Always run full test suite..."

After any success, record the narrative:

python3 tetra_scar.py narrate --what "Deployed v2.1 after full test pass" --who "Users"

How the reflex arc works

The reflex arc extracts keywords from each scar's never_again field:

• English words (3+ characters)
• Japanese kanji/katakana units (2+ characters)

When a task description matches 40%+ of a scar's keywords (minimum 2), it's blocked. No LLM judgment. No API calls. No latency. Pure pattern matching.

The 4-axis check (tetra-check)

For deeper validation, tetra-check evaluates a task against 4 axes:

1. Emotion axis: Does the task have motivation? (non-empty description)
2. Action axis: Is it concrete? (contains action verbs)
3. Life axis: Does it collide with any scar? (reflex arc)
4. Ethics axis: Does it involve dangerous operations? (rm -rf, DROP TABLE, etc.)

All 4 must pass. Any failure rejects the task with a specific reason.

python3 tetra_scar.py tetra-check --task "Refactor the auth module"
# Output: APPROVED — all 4 axes passed

File format

JSONL (one JSON object per line). Human-readable. Git-friendly.

scars.jsonl: {"id":"scar_001","what_broke":"...","never_again":"...","created_at":"..."} narrative.jsonl: {"id":"narr_001","what":"...","who_benefited":"Users","created_at":"..."}

Integration

from tetra_scar import reflex_check, read_scars, write_scar, write_narrative

# Before execution
scars = read_scars()
block = reflex_check(task_description, scars)
if block:
    print(f"BLOCKED: {block}")
else:
    # execute task...
    if failed:
        write_scar("What broke", "What must never happen again")
    else:
        write_narrative("What was done", "Who benefited")

Philosophy

Built by Tetra Genesis (B Button Corp, Nagoya, Japan).

Agents that can't remember their failures are doomed to repeat them. Scars are not bugs — they're the immune system. Every cycle must answer: "Who did this make happy?"