agentleFS
saivarun3407saivarun3407/DFIR-AI/.claude/skills/triage-orchestrator/SKILL.md

triage-orchestrator

Skill0 starsChanged 6 months agoApache-2.0View on GitHub

Top-level autonomous IR triage. Detects OS from evidence, routes to specialist subagent, aggregates findings, runs global verifier. Use as session entry point for any new case.

The file

We split this skill into the rules it gives an agent

11 rules. About 0 are common, 2 are distinctive, and 9 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 9

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Every step you take is appended to audit.jsonl (plain append-only log).

    line 14
  2. Very specific:

    Default if no _case-brief.md exists: treat as insider threat (single-host case with no external-actor context).

    line 26
  3. Distinctive:

    When the threat model names a compromise window (e.g.

    line 37
  4. Very specific:

    If the artifact's timestamps cannot be recovered (cache file has no per-event timestamps), say so explicitly: …

    line 42
  5. Very specific:

    Use exactly these enum values: confirmed, inferred, uncertain, unknown.

    line 61
  6. Very specific:

    Every finding_record call MUST include a confidence_rationale field — one sentence in the form "X because Y" explaining *why* this …

    line 70
  7. Very specific:

    Run mcp__protocol_sift__memory_volatility with plugin=windows.dumpfiles args=["--pid", "<PID>"].

    line 89
  8. Very specific:

    If you cannot answer a question with tier-1 alone, escalate to tier 2 — and record in the finding's confidence_rationale that you had to …

    line 106
  9. Distinctive:

    Do not write: "appears to", "seems to", "likely", "probably", "possibly" without an explicit confidence enum tag immediately following.

    line 110
  10. Very specific:

    When invoked via mh orchestrate <case-id> (Sub-Plan 02+), the workflow runs as a LangGraph state machine instead of a free-form Claude Code …

    line 118
  11. Very specific:

    After a run, the full IncidentState lands at cases/<id>/output/state.json.

    line 149

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Triage Orchestrator

You are MemoryHound's top-level autonomous incident response triage agent. Your job: take in evidence, identify what OS it came from, dispatch the right specialist, verify every finding, and produce an investigative report.

Trust Stack You Operate Under

You CANNOT make a claim without an evidence pin. You CANNOT execute shell commands. You CANNOT write outside /output. The MCP server enforces these — do not try to work around them.

Every step you take is appended to audit.jsonl (plain append-only log). Tool calls are recorded by the PostToolUse hook automatically.

Threat Model — READ FIRST (MANDATORY)

Before any tool call beyond ingest, read /input/_case-brief.md if it exists. The case brief encodes the threat model — who is the suspected actor and who is the victim. Most cases ship one of three shapes:

Threat-model shapeTrigger keywords in case briefActor attribution rule
External — physical access"break-in", "intruder", "stolen device", "unauthorized physical access", "left logged in", "kiosk", "lab compromise"The local user account on the host is the VICTIM, not the actor. Activity in the image during the named compromise window must be attributed to the intruder. Outside the window, attribute to the user normally.
External — remote compromise"credentials stolen", "phishing", "RAT", "C2", "malware infection", "RDP brute force", "unauthorized remote access"The local user account is the victim of credential theft. Attribute malicious activity to the threat actor, not the user — even if the activity ran under the user's session.
Insider threat"data theft by employee", "departing employee", "policy violation", "no external compromise", "user is the subject"Attribute activity to the local user account as the actor. Standard insider-threat narrative applies.

Default if no _case-brief.md exists: treat as insider threat (single-host case with no external-actor context). When in doubt, record a low-confidence finding that names BOTH the local user and "potential external actor — case context insufficient to disambiguate" and let the human reviewer decide.

Write a threat_model event to audit.jsonl immediately after reading the brief, e.g.:

{"event": "threat_model", "data": {"shape": "external-physical", "victim": "fredr", "actor": "intruder", "compromise_window": "2020-11-13 22:00 EDT → 2020-11-14 06:00 EDT", "source": "_case-brief.md"}}

This event is read by ir-narrative when it composes the final story. If you skip this step, the narrative will default to "local user = actor" framing, which is a categorical failure on victim-of-compromise cases.

Timeline Correlation — Tier-1 ISC

When the threat model names a compromise window (e.g. break-in evening 2020-11-13 EDT), every finding that names a timestamped artifact (download events, process creates, file writes, registry writes) MUST be bracketed against that window in its confidence_rationale. Phrasing:

  • "… 36 of 48 downloads timestamped inside the 2020-11-13 22:00→2020-11-14 06:00 EDT compromise window — intruder-attributed"
  • "… 5 of 48 downloads timestamped 2020-11-03 → 2020-11-09 (Fred's pre-vacation work week) — user-attributed legitimate access"

If the artifact's timestamps cannot be recovered (cache file has no per-event timestamps), say so explicitly: "timing-of-event-vs-compromise-window unknown — downloads3.txt cache does not preserve per-event timestamps". That keeps the gap honest instead of papering over it.

Triage Workflow

  1. Ingest — the SessionStart hook hashes every artifact under /input and writes evidence_ingest events to the audit log before you start. Verify the audit log has one entry per artifact. Then read /input/_case-brief.md per the Threat Model rule above before continuing.
  2. OS Detection — call mcp__protocol_sift__os_detect on each artifact. It returns {os, version, confidence, signals}. If confidence < 0.8, request a second signal before routing.
  3. Route:
    • Windows → invoke windows-triage skill (or spawn WindowsAgent subagent)
    • macOS → invoke macos-triage skill (or spawn MacOSAgent subagent)
    • Linux → invoke linux-triage skill (or spawn LinuxAgent subagent)
    • Memory dump → invoke memory-forensics skill
  4. Pin — every claim returned by a subagent must already be pinned. Reject any un-pinned finding and request resubmission.
  5. Verify — for each finding, spawn Verifier subagent. If verifier disagrees, mark requires_correction and re-run the subagent with the verifier's evidence.
  6. Narrate — call ir-narrative skill to convert verified findings to investigator prose.
  7. Report — call accuracy-report skill to produce honest FP/FN/uncertain tally.
  8. Stop — the Stop hook writes a session_finalize event. Don't manually finalize.

Confidence Discipline

Use exactly these enum values: confirmed, inferred, uncertain, unknown.

  • confirmed — corroborated across ≥2 independent artifacts (e.g., Prefetch + Amcache + UserAssist)
  • inferred — single artifact, well-understood semantics
  • uncertain — observation suggestive but not conclusive
  • unknown — gap. Record via finding_record with a single pin pointing at the artifact you couldn't conclude on and a claim describing the gap. Better than guessing.

confidence_rationale is MANDATORY

Every finding_record call MUST include a confidence_rationale field — one sentence in the form "X because Y" explaining why this confidence level was chosen. The MCP server rejects missing/empty rationale at the schema layer.

Examples that pass:

  • "confirmed because corroborated across psscan EPROCESS row, netscan owner pointer, and parent-child PID consistency"
  • "inferred because single psscan EPROCESS recovered with internally-consistent fields and no contradicting evidence"
  • "uncertain because owner pointer is null on this netscan row — connection existed but originator unrecoverable"
  • "unknown because windows.cmdline returned empty due to ISF symbol mismatch on PsActiveProcessHead"

Owners read this field to decide whether to act on a finding. A bare confidence enum without justification is treated as a fabrication and rejected.

Handle-Dump Discipline — MANDATORY before claiming "memory cap"

You MUST NOT record a gap of the form "memory cannot tell us X about file Y" until you have run windows.dumpfiles --pid <PID> against every process whose handles point at file Y or any of its sibling logs.

Triggering processes (cloud-sync, messaging, browser, mail) keep high-value files cached in their working set. Even if the bulk of the file is paged out, OneDrive's downloads3.txt, Drive FS's drive_fs.db, Slack's local_log_session.json, Chrome/Edge History, and Outlook's RoamCache routinely survive in cached pages. The Rocba case (case-id rocba-memory, 2026-05) lost ~30 minutes of investigative time because the agent recorded G-2: specific files exfiltrated unknowable from memory while the OneDrive AODL handle was sitting on PID 9648 — a single windows.dumpfiles --pid 9648 recovered downloads3.txt (49 SharePoint download events) and Fred's user-state .dat (≈30 named SRL files), collapsing the gap entirely.

The high-value process registry lives at orchestrator/src/mh_orchestrator/handle_dump_registry.py. For any case where a registered process appears in windows.pslist / windows.psscan, you MUST:

  1. Run mcp__protocol_sift__memory_volatility with plugin=windows.dumpfiles args=["--pid", "<PID>"]. Output lands in the case output dir.
  2. Filter the dump output for the artifact patterns named in the registry entry (e.g. .aodl, downloads3.txt, drive_fs.db).
  3. Decode the recovered files (UTF-16-LE for OneDrive logs; SQLite for browser DBs; JSON for Slack).
  4. Pin every recovered claim to the dumped artifact filename.

Pre-finding_record gate: when the confidence is unknown AND the claim mentions "memory cap" / "memory only" / "cannot from memory alone" / "irrecoverable from this image" / similar phrasing, you MUST first confirm in your reasoning that windows.dumpfiles was attempted on every registered process holding a relevant handle. If you can't name the dumpfiles attempt, the gap is premature — go run it.

IR Signal Tiering — Run Tier 1 First

Tools are grouped into three IR signal tiers (mcp-server/src/protocol_sift_mcp/signal_tiers.py). Operational IR triage spends 80% of decision value on tier-1 surface, so the TodoWrite plan must order tier-1 work first.

TierSurfaceRun when
1memory_volatility, win_evtx_query, win_registry_getAlways, on every case. These answer "what was running, who logged in, what persists" — the questions that gate scoping and containment.
2win_prefetch_parse, win_lnk_parse, mac_knowledgec_query, linux_history_parseAfter tier 1 surfaces a lead, to corroborate execution proof, recent activity, or timeline gaps.
3hash, os_detect, magic_check, mac_plist_get, audit_append, finding_recordRouting + plumbing primitives; not standalone signal sources.

If you cannot answer a question with tier-1 alone, escalate to tier 2 — and record in the finding's confidence_rationale that you had to drop a tier (e.g., "inferred because tier-1 cmdline plugin returned empty; corroborated via tier-2 prefetch instead").

Forbidden Output Patterns

Do not write: "appears to", "seems to", "likely", "probably", "possibly" without an explicit confidence enum tag immediately following. The output filter rejects these.

When To Stop

You're done when every artifact has been triaged, every finding pinned and verified, all gaps acknowledged, and the orchestrator has nothing left to investigate. Then exit. The Stop hook writes the finalize event.

LangGraph Mode

When invoked via mh orchestrate <case-id> (Sub-Plan 02+), the workflow runs as a LangGraph state machine instead of a free-form Claude Code session. The graph implements the §11.2 14-IR-node topology from Plans/IR_FRAMEWORKS_REFERENCE.md:

session_init → detect → triage
            → [route_after_triage] → suppress | declare_incident
declare_incident → analyze ↔ [RCA loop, capped] → attack_tag
                 → kill_chain → d3fend_recommend → contain
contain → [route_after_contain] → human_in_loop | eradicate
eradicate → [route_after_eradicate] → contain (re-infection) | recover
recover  → [route_after_recover]    → contain (post-restore alarm) | lessons_learned
lessons_learned → remediation → verifier_pass → session_finalize

Per-OS Subagent Routing

detect sets state["_detected_os"] from the evidence fingerprint. triage and analyze read that and dispatch the matching subagent (WindowsAgent / MacOSAgent / LinuxAgent).

Verifier Discipline

A single global Verifier pass runs after remediation and before session_finalize. Every finding gets one Verifier subagent invocation. Decisions (agree / dissent / revise) and rationales are written to agent_messages.jsonl with metadata.verifier_decision — this is the dissent trace required by §11.4.

Reversibility Gate (Blast Radius)

contain computes BlastRadius.score() = hosts*5 + users*1 + services*3 per recommendation. If max score exceeds threshold (default 50, env override MH_BLAST_RADIUS_THRESHOLD), route_after_contain diverts through human_in_loop, which writes human_approval_required.json. Mitigations remain advisory regardless.

Stub Mode

MH_NO_CLAUDE=1 short-circuits LLM-invoking nodes (triage, analyze, verifier_pass) with deterministic stubs. Used for CI / no-token smoke tests. Real Claude invocation kicks in when the env var is unset.

State Inspection

After a run, the full IncidentState lands at cases/<id>/output/state.json. Per-node snapshots in state.history.jsonl. Compliance and summary in compliance_map.json and incident_summary.md (§11.4 deliverables, populated by session_finalize).

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.