immune
Hybrid adaptive system v5.3.0: Vector engine (local MiniLM by default, optional GPU daemon auto-detected on EMBED_PORT + cross-encoder re-ranking) + FTS4 via RRF. Cheatsheet (positive) + Immune (negat
SKILL.mdskill.md
GitHubUpgrade
npm update -g @mnemoclaw/immune && immune
Both steps: npm update refreshes the package, immune init refreshes the copy of the adapter this skill executes. npm update alone has no runtime effect.
immune version shows the package version AND the version actually installed in the skill dir, so drift is visible. The adapter reports its own version via node immune-adapter.js version and the version field of stats.
Immune System v4 — Hybrid Cheatsheet + Immune
You operate a hybrid adaptive system with two complementary memories:
- Cheatsheet (positive patterns): domain-specific strategies injected BEFORE generation to improve output quality
- Immune (negative patterns): antibodies that detect known errors and discover new threats AFTER generation
Both memories use Hot/Cold tiering to keep context lean.
All data access goes through the adapter CLI (node ~/.claude/skills/immune/immune-adapter.js).
Input Parsing
The user invokes with content to scan. Parse these parameters:
- input: The text/code/content to scan (required — either inline or from context)
- domain: One of: domain, code, writing, research, strategy, webdesign, _global (default: auto-detect)
- domains: Array of domains (overrides single domain). Example:
domains=domain,code - constraints: Any specific requirements the output should satisfy (optional)
- mode:
full(cheatsheet + scan, default) |scan-only(skip cheatsheet) |cheatsheet-only(return cheatsheet, no scan)
If no inline text is provided, scan the last substantive output in the conversation.
Shortcuts:
/immune scan→ Full conversation scan inmode=full. Extracts BOTH new threats (antibodies) AND new good practices (strategies). Domains auto-detected. This is the standard "make this conversation teach the system" command./immune(bare) → Same asscanif there is conversation context; otherwise scans the last output only.
Whenever the user invokes /immune scan or just says "scan la conversation" / "scan this conversation", default to extracting both threats AND strategies over the entire conversation history, in mode=full. Do not require the user to repeat "menaces + stratégies" — that is the default intent of scan.
Domain auto-detection: Read ~/.claude/skills/immune/config.yaml and match content against domain_keywords. If no strong match, use ["_global"]. If single domain string provided, wrap in array: domains = [domain].
Execution
Step -1 — Context Search (past session awareness)
Search for relevant past sessions to inform the current scan:
node ~/.claude/skills/immune/immune-adapter.js get-context --query "{task keywords or domain}" --days 90 --limit 5
If results are found, note recurring patterns or past issues for the domain. This enriches the scan with historical awareness — the scanner will know if similar content was flagged before.
Log: [IMMUNE] Context: {count} relevant past sessions found
Step 0 — Cheatsheet Injection (positive patterns)
Skip this step if mode == "scan-only".
0a. Load HOT strategies via adapter:
Run:
node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier hot --limit 15
Parse the JSON output. The adapter returns strategies pre-filtered by domain, classified as HOT, sorted by effectiveness descending, and capped at 15.
0b. Load COLD strategies summary:
Run:
node ~/.claude/skills/immune/immune-adapter.js get-strategies --domains '{domains_json}' --tier cold
Extract a short keyword from each COLD strategy's pattern field. Join as comma-separated list.
0c. Build cheatsheet block: Format HOT strategies as XML:
<cheatsheet domain="{domains}">
<strategy id="{id}" effectiveness="{effectiveness}">
{pattern}
Example: {example}
</strategy>
...
</cheatsheet>
If there are COLD strategies, add a one-liner:
<cheatsheet_cold>Also consider: {comma-separated COLD pattern keywords}</cheatsheet_cold>
If mode == "cheatsheet-only", output the cheatsheet block and stop here.
Log:
[IMMUNE] Cheatsheet: {n_hot} HOT + {n_cold} COLD strategies (domains: {domains})
0d. Present cheatsheet to user:
If running standalone (/immune), show the cheatsheet as context the user should apply to their next generation. If called by Chimera, return the XML block for injection into PRISM prompts.
Step 1 — Load & Classify Antibodies (Hot/Cold)
1a. Load HOT antibodies via adapter:
Run:
node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier hot --limit 15
The adapter returns antibodies pre-filtered by domain, classified as HOT (severity=critical OR seen_count>=3 OR last_seen<30d), sorted by severity then seen_count, capped at 15.
1b. Load COLD antibodies summary:
Run:
node ~/.claude/skills/immune/immune-adapter.js get-antibodies --domains '{domains_json}' --tier cold
For each COLD antibody, extract a short keyword from its pattern field.
Join as comma-separated list.
Log:
[IMMUNE] Tier split: {n_hot} HOT + {n_cold} COLD / {n_hot + n_cold} total (domains: {domains})
Step 2 — Scan
Spawn the immune-scan agent (Haiku) with the following XML-structured prompt:
<scan_request>
<domains>{detected_domains as JSON array}</domains>
<task>{task description or "Scan the following content for errors and threats"}</task>
<constraints>{constraints or "none"}</constraints>
<content>
{the input text/code/content to scan}
</content>
<hot_antibodies>
{JSON array of HOT antibodies — full objects with id, domains, pattern, severity, correction}
</hot_antibodies>
<cold_summary>
Dormant patterns (not detailed, for awareness only): {comma-separated COLD keywords}
</cold_summary>
<cheatsheet_applied>
{list of strategy IDs and patterns that were injected in Step 0, or "none" if scan-only mode}
</cheatsheet_applied>
</scan_request>
Log: [IMMUNE] Scanning... ({n_hot} active antibodies)
Wait for result.
If corrections applied:
Log: [IMMUNE] Match {antibody_id}: {original} → {corrected}
If new threats detected:
Log: [IMMUNE] New threat: {pattern}
If new strategies detected:
Log: [IMMUNE] New strategy: {pattern}
Step 3 — Update Immune Memory (with COLD deduplication)
3a. Matched HOT antibodies: For each antibody matched by the scanner, update via adapter:
node ~/.claude/skills/immune/immune-adapter.js update-antibody --id {antibody_id} --increment_seen true --last_seen {today}
3b. New threats — deduplicate via similarity scoring:
For each new threat in new_threats_detected:
- Check for duplicate using multi-criteria similarity (Jaccard + substring + domain):
node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type antibody
Returns { duplicate: true/false, best_match: { id, score, pattern }, threshold: 0.7 }
- If duplicate is true (score >= 0.7, same domain + similar pattern) → REACTIVATE:
- Update the matched antibody:
update-antibody --id {matched_id} --increment_seen true --last_seen {today} - Log:
[IMMUNE] Reactivated COLD antibody {id}: {pattern} - Skip new antibody creation (deduplication preserves a single source of truth)
- Update the matched antibody:
- If no match AND
auto_add_threatsis true → CREATE new antibody:
node ~/.claude/skills/immune/immune-adapter.js add-antibody --json '{"id":"AB-{next_number}","domains":{domains},"pattern":"{pattern}","severity":"{severity}","correction":"{correction}","seen_count":1,"first_seen":"{today}","last_seen":"{today}"}'
- Log:
[IMMUNE] + New antibody {id}: {pattern}
3c. Get updated stats:
node ~/.claude/skills/immune/immune-adapter.js stats
Log: [IMMUNE] Memory: {total} antibodies ({n_hot} hot, {n_cold} cold) | +{new} added | Reactivated: {reactivated}
Step 3b — Update Cheatsheet Memory (positive patterns)
Skip if mode == "scan-only" or no new_strategies_detected in scan result.
3b-i. Deduplicate via similarity scoring:
For each new strategy in new_strategies_detected:
- Check for duplicate using multi-criteria similarity:
node ~/.claude/skills/immune/immune-adapter.js check-duplicate --pattern "{pattern}" --domains '{domains_json}' --type strategy
- If duplicate is true (score >= 0.7, overlapping domains + similar pattern) → REINFORCE:
- Calculate new effectiveness:
new_eff = old_eff * 0.8 + reported_eff * 0.2(exponential moving average) - Update:
update-strategy --id {matched_id} --increment_seen true --last_seen {today} --effectiveness {new_eff} - Log:
[IMMUNE] Reinforced strategy {id}: {pattern} (eff: {old}→{new})
- Calculate new effectiveness:
- If no match AND
auto_add_strategiesis true → CREATE new strategy:
node ~/.claude/skills/immune/immune-adapter.js add-strategy --json '{"id":"{prefix}-{next_number}","domains":{domains},"pattern":"{pattern}","example":"{example}","effectiveness":{eff},"seen_count":1,"first_seen":"{today}","last_seen":"{today}"}'
- Log:
[IMMUNE] + New strategy {id}: {pattern}
3b-ii. Prune low-effectiveness:
If any strategy has effectiveness < 0.2 AND seen_count >= 5, note it for manual review.
Log: [IMMUNE] Cheatsheet: {total} strategies | +{new} added | Reinforced: {reinforced}
Step 4 — Score
Calculate the universal score via adapter:
node ~/.claude/skills/immune/immune-adapter.js score --domains '{domains_json}' --severities '[{"severity":"critical","count":N},{"severity":"warning","count":N},{"severity":"info","count":N}]'
The adapter returns: score (0-100), pass (boolean), z (z-score vs domain baseline), baseline (mean, std, threshold, n), deductions.
Step 5 — Output
If clean:
───
IMMUNE v4 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
Baseline ({domain}): mean={mean} std={std} threshold={threshold}
Cheatsheet: {n_strategies} strategies applied | Antibodies: {n_hot}/{max} HOT, {n_cold} COLD
No issues detected
───
If corrections or threats found:
───
IMMUNE v4 | domains={domains} | Score: {score}/100 ({PASS|FAIL}) | z={z}
Baseline ({domain}): mean={mean} std={std} threshold={threshold}
Corrections Applied:
[AB-XXX] {pattern} → {correction}
New Threats Detected:
[{severity}] {pattern} — {suggested_correction}
Reactivated:
[AB-XXX] {pattern} (was COLD, now HOT)
New Strategies Learned:
[CS-XXX] {pattern} (eff: {effectiveness})
───
Corrected Output:
{the corrected content, formatted for the domain}
───
Memory: {total_ab} antibodies + {total_cs} strategies | +{new_ab} AB | +{new_cs} CS
───
Then present the corrected output in a human-readable format appropriate to the domain.
Step 6 — Session Log
Log the session result for future context:
node ~/.claude/skills/immune/immune-adapter.js log-session --date {today} --domains '{domains_json}' --result {clean|corrected|flagged} --summary "{brief summary of what was scanned and found}" --score {score}
This writes to context/YYYY-MM-DD.md + SQLite session_logs + FTS4 index for future get-context searches.
Step 7 — Flush Pre-Compaction (optional)
If the conversation context is approaching compaction, save any pending antibodies/strategies that haven't been committed yet:
node ~/.claude/skills/immune/immune-adapter.js flush-pending --json '{"antibodies":[...],"strategies":[...]}'
Quality gate validation:
- Pattern must be >= 20 characters
- Antibodies require: id, pattern, severity, correction
- Strategies require: id, pattern
- FTS4 duplicate check prevents re-creating existing patterns
- Flushed records are flagged with
quality_gate=1
Log: [IMMUNE] Pre-compaction flush: +{n} antibodies, +{n} strategies (quality_gate=true)
Error Handling
- If adapter CLI fails: fall back to reading JSON files directly (
immune_memory.json,cheatsheet_memory.json) — they are kept in sync via dual-write. - If
immune_memory.jsondoes not exist: adapter auto-creates it with empty antibodies. - If
cheatsheet_memory.jsondoes not exist: adapter auto-creates it with empty strategies. - If
immune_memory.jsonhas"version": 2: adapter auto-migrates"domain"to"domains": ["domain_value"]. - If the agent returns invalid JSON: retry once. If still invalid, report the raw output with a warning.
- If no input is provided and no recent output exists: ask the user what to scan.
- If all antibodies are COLD (none qualify as HOT): still send the scan with empty
hot_antibodiesarray and fullcold_summary. Haiku can still detect new threats via Phase 2.