Chronicle logo

Chronicle

Community
brucesongs
chronicle

A system for recording, indexing, and distilling knowledge from agent lifecycle events. Through a three-layer document system (overview -> detailed records -> knowledge distillation), raw conversation events are transformed into reusable experience.

Overview

Publisherbrucesongs
Repositorykali-claw
Skill namechronicle
Stars
70
Forks
18
Bundled files
15
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 15 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by brucesongs on GitHub. Read the source before you install it.

Installation

Install the Chronicle AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/brucesongs/kali-claw.git /tmp/kali-claw
mkdir -p .claude/skills
cp -r /tmp/kali-claw/skills/chronicle .claude/skills/chronicle
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Chronicle in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Chronicle on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Chronicle is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Skill: Chronicle System

Supplementary Files:

  • chronicle-template.py — Chronicle detailed record template generator (Python script that automatically generates event record files and creates directory structures)

Summary

Through a three-layer document system (overview -> detailed records -> knowledge distillation), raw conversation events are transformed into reusable experience.

Tools: MEMORY.md, HEARTBEAT.md, TOOLS.md, skills/

Domain: knowledge

Description

A system for recording, indexing, and distilling knowledge from agent lifecycle events. Through a three-layer document system (overview -> detailed records -> knowledge distillation), raw conversation events are transformed into reusable experience.

Distinction from MEMORY.md: Chronicle records "what happened," while MEMORY.md records "what was learned."


Use Cases

  • Completing a major security discovery (high-severity vulnerability, data breach)
  • Achieving a key milestone (learning plan completion, tool mastery)
  • Important environment or configuration changes
  • Need to quickly review historical events and handling approaches
  • Periodic archiving of expired logs from memory/

Three-Layer Architecture

+------------------------------------------+
|  Layer 1: CHRONICLE.md (Overview Index)  |
|  Timeline + one-line summary + nav links |
+------------------+-----------------------+
                   |
                   v
+------------------------------------------+
|  Layer 2: chronicle/YYYY-MM/             |
|  YYYY-MM-DD-event-name.md (Detail)       |
|  Background, process, results, outputs,  |
|  impact                                   |
+------------------+-----------------------+
                   |
                   v
+------------------------------------------+
|  Layer 3: MEMORY.md (Knowledge Distill)  |
|  Experience, lessons, capability growth   |
+------------------------------------------+

Event Classification

TypeIconPriorityTrigger Condition
Security Discoveryred_circleP0 Record immediatelyHigh-severity vulnerability, data breach, credential exposure
Milestone Achievedparty_popperP0 Record immediatelyLearning plan completed, full tool mastery
Project LaunchrocketP1 Record same dayNew phase, new goal, new environment
Learning CompletedbooksP1 Record same dayTool learning, skill mastery, certification passed
Environment ConfigwrenchP1 Record same dayToolchain, system configuration, network changes
Report DeliveredpageP1 Record same dayPenetration test report, security assessment
System OptimizationgearP2 Record this weekWorkflow improvement, directory cleanup
Goal SettingdartP2 Record this weekNew plans, new directions

Event Template

File path: chronicle/YYYY-MM/YYYY-MM-DD-event-name.md

markdown
# YYYY-MM-DD - Event Name

> **Type**: [icon] [type name]
> **Priority**: P[0/1/2]
> **Recorded**: YYYY-MM-DD HH:MM

---

## Background

[Why this was done]

---

## Process

### Phase 1: [Name]
- **Action**: [What was done]
- **Result**: [What happened]

### Phase 2: [Name]
- **Action**: [What was done]
- **Result**: [What happened]

---

## Outputs

- `path/to/file` — [description]

---

## Impact

[Significance for future work]

---

## Related

- Daily notes: `memory/YYYY-MM-DD.md`
- Knowledge distillation: `MEMORY.md#[section]`
- Related skill: `skills/[skill-name]/SKILL.md`

Index Format

File path: CHRONICLE.md (root directory)

markdown
# Chronicle

## YYYY-MM

### YYYY-MM-DD (Weekday) — Event Name
**Type**: [icon] [type name] | **Priority**: P[0/1/2]

[One-line summary]

**Outcomes**: [key outcomes]
**Details**: -> chronicle/YYYY-MM/YYYY-MM-DD-event-name.md

---

Workflow

Recording Events

1. Determine event type and priority (refer to classification table)
2. Create detailed record file (use template)
3. Update CHRONICLE.md overview index
4. If lessons learned -> distill to MEMORY.md

Periodic Maintenance (Heartbeat Task Integration)

FrequencyOperation
Every heartbeatCheck if P0 events need recording
WeeklyReview CHRONICLE.md completeness, fill gaps
MonthlyGenerate monthly summary, archive expired memory files to chronicle
QuarterlyReview classification system, optimize templates

Memory Archiving Rules

When logs in memory/ exceed 30 days:

  1. Extract important content to corresponding chronicle detailed records
  2. Distill lessons learned to MEMORY.md
  3. Retain original memory files but mark as archived

Detection Methods

Chronicle SIEM Native Detections

  • YARA-L rules: Chronicle's detection language; matches patterns across events.
  • Asset graph anomalies: Sudden connections between previously unrelated assets.
  • Statistical outliers: Login time anomalies; data transfer size outliers.
  • IOC matches: Hashes, IPs, domains matched against threat intel.
  • UDM (Unified Data Model) enrichment: All events normalized; cross-source correlation.

Common Rule Categories

  • Initial access: Suspicious email attachment exec; new ASN login + admin action.
  • Persistence: New scheduled task with system privileges; new service binary in temp dir.
  • Lateral movement: SMB connections from non-admin workstation; RDP to domain controller.
  • Exfiltration: DNS tunneling signatures; large uploads to unknown cloud storage.

Sample YARA-L Rule

yara
rule suspicious_powershell_download {
  events:
    $e.metadata.event_type = "PROCESS_LAUNCH"
    $e.principal.process.command_line /= /powershell.*DownloadFile/
  condition:
    $e
}

Defense Evasion Techniques

Bypassing Chronicle Ingestion

  • Avoid UDM-enriched sources: Target data sources not yet normalized (less detectable).
  • Slow operations: Spread actions across the 24h+ retention window for correlation.
  • Compromise logging pipeline: Modify syslog forwarder to drop specific events.
  • Use legitimate credentials: Don't trigger new-login alerts; use stolen but valid tokens.
  • Time-stomp before event ingestion: Modify file timestamps before they're collected.

Rule Bypass

  • Avoid known YARA-L patterns: Don't use DownloadFile keyword; use base64 encoded command.
  • Distribute across rules: Avoid triggering any single rule's threshold (e.g., 5+ failed logins).
  • Off-hours activity: Run during peak business hours to blend with normal traffic.
  • Piggyback on legitimate admin actions: Trigger detection in same window as scheduled maintenance.

Hacker Laws

LawApplication
First PrinciplesReturn to the essence of events when recording, don't pile on details
Trust but VerifyPeriodically verify chronicle records match reality
Free Information FlowShare experiences and lessons in MEMORY.md, don't hoard

System Integration

SystemRelationship
MEMORY.mdChronicle records events, MEMORY distills knowledge
HEARTBEAT.mdHeartbeat triggers periodic maintenance and P0 event checks
TOOLS.mdTool mastery milestones recorded to chronicle
skills/Skill learning completions recorded to chronicle

Based on CHRONICLE_SYSTEM.md, condensed and rewritten

Orchestration

ECC Loop Pattern

  • Pattern: Sequential Pipeline (record event → index in chronicle → distill to MEMORY.md)
  • Rationale: Chronicle follows a strict three-layer progression — raw events are recorded first, then indexed for navigation, then selectively distilled into long-term knowledge
  • Integration: continuous-learning (feeds knowledge extraction), safety-guard (incident events), HEARTBEAT.md (periodic maintenance triggers), TOOLS.md (tool mastery milestones)

Cross-Skill Pipeline

[any skill event] → chronicle (record) → CHRONICLE.md (index) → MEMORY.md (distill)
                          ↓                                      ↑
                   safety-guard (incidents)          continuous-learning (patterns)

Quality Gate

  • Pre-condition: Event meets recording threshold (P0-P2 priority classification)
  • Post-condition: Event recorded in chronicle/YYYY-MM/, indexed in CHRONICLE.md, lessons distilled to MEMORY.md if applicable
  • Verification: CHRONICLE.md index matches detail files, MEMORY.md reflects distilled knowledge

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Chronicle AI skill do?

A system for recording, indexing, and distilling knowledge from agent lifecycle events. Through a three-layer document system (overview -> detailed records -> knowledge distillation), raw conversation events are transformed into reusable experience.

Why use Chronicle on TypingMind?

Because you install it once and use it with any model. Chronicle is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Chronicle in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/brucesongs/kali-claw/tree/main/skills/chronicle. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Chronicle?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Chronicle?

As many as you like. As long as a model supports skills, you can use Chronicle with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Chronicle AI skill free?

Yes. It is published on GitHub by brucesongs under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇