colibri-audit-memory

Category: Testing & Security | Uploader: LastEld | Downloads: 0 | Version: v1.0（Latest）
Bridge audit trails and memory frames for comprehensive session recording. Greek: ζ (zeta) — Decision Trail, η (eta) — Proof Store. Use when recording audit sessions, creating memory bundles, linking audit trails to memory, or finalizing session proofs with memory archives.
Changelog: Source: GitHub https://github.com/LastEld/AMS
Directory Structure

Current level: tree/main/.agents/skills/colibri-audit-memory/
📁 agents/
- 📄 openai.yaml 299 B
📁 references/
- 📄 tools.md 1.8 KB
- 📄 workflows.md 1.4 KB
📄 SKILL.md 7.1 KB
SKILL.md

---
name: colibri-audit-memory
description: Bridge audit trails and memory frames for comprehensive session recording. Greek: ζ (zeta) — Decision Trail, η (eta) — Proof Store. Use when recording audit sessions, creating memory bundles, linking audit trails to memory, or finalizing session proofs with memory archives.
---

# Colibri Audit Memory

> Greek letters: **ζ (zeta)** — Decision Trail · **η (eta)** — Proof Store

Use this skill to integrate audit trails with memory frames for comprehensive session recording and archival.

## Quick Start

Run this bootstrap sequence first:

1. `unified_init`
2. `unified_vitals`
3. `unified_help`
4. `audit_session_start` with descriptive session_id
5. `memory_pack` to gather session data

Treat `src/server.js` as the active server and `archive/` as reference only.

## When to Use This Skill

- Starting audit sessions that need comprehensive memory archival
- Creating immutable records of decisions and actions
- Building memory bundles with full audit trail context
- Finalizing sessions with both Merkle proofs and memory archives
- Linking audit records to memory frames for cross-referencing
- Recovering session state from memory for interrupted work

## Core Concepts

### Audit Trail vs. Memory

| Aspect | Audit Trail | Memory |
|--------|-------------|--------|
| Purpose | Immutable action log | Context and reasoning cache |
| Structure | Hash chain | Frame graph with links |
| Proof | Merkle tree | Vector indexes |
| Access | Query by session/action | Semantic search, LLM retrieval |
| Lifecycle | Forever (immutable) | Tiered (hot/warm/cold) |

### Integration Points

1. **Session Start**: Create audit session → Create context snapshot → Pack initial memory
2. **During Work**: Record actions → Add thoughts → Update memory with incremental changes
3. **Session End**: Finalize audit chain → Merkle finalization → Bundle memory with proofs

## Core Tools

### Audit Session + Memory Integration

- `audit_session_start` - Start audit session
- `context_create` - Create immutable context (for memory snapshotting)
- `memory_pack` - Pack context, actions, thoughts into memory frames
- `thought_record` - Record reasoning (added to both audit trail and memory)
- `audit_verify_chain` - Verify audit chain integrity
- `memory_verify` - Verify memory frame checksums
- `merkle_finalize` - Finalize both audit and memory proof
- `memory_bundle` - Create prompt-ready bundle with audit context

## Usage Examples

### Start Session with Memory

```json
{
  "tool": "audit_session_start",
  "params": {
    "session_id": "colibri-phase2-impl-001",
    "context_id": 123
  }
}
// Then: memory_pack with same session_id
```

### Record Decision with Audit + Memory

```json
{
  "tool": "thought_record",
  "params": {
    "session_id": "colibri-phase2-impl-001",
    "thought_type": "decision",
    "content": "Chose async pattern for task dispatch due to high throughput requirement"
  }
}
// This action goes to BOTH audit trail and memory frames
```

### Pack Session Memory

```json
{
  "tool": "memory_pack",
  "params": {
    "session_id": "colibri-phase2-impl-001",
    "source_types": ["context", "action", "thought"],
    "include_audit": true
  }
}
```

### Build Audit + Memory Bundle

```json
{
  "tool": "memory_bundle",
  "params": {
    "session_id": "colibri-phase2-impl-001",
    "token_budget": 2000,
    "include_rag": false,
    "include_audit_trail": true
  }
}
```

### Finalize with Proof

```json
{
  "tool": "merkle_finalize",
  "params": {
    "session_id": "colibri-phase2-impl-001"
  }
}
// Finalizes both audit chain and memory indexes
```

## Session Lifecycle

```
1. audit_session_start
   ↓
2. context_create (optional but recommended)
   ↓
3. memory_pack (initial)
   ↓
4. [Work: thought_record, audit actions, code commits, etc.]
   ↓
5. memory_pack (incremental updates)
   ↓
6. audit_verify_chain
   ↓
7. memory_verify
   ↓
8. merkle_finalize
   ↓
9. memory_bundle (final prompt-ready archive)
   ↓
10. audit_session_end
```

## Memory Frame Structure with Audit Context

Each memory frame contains:

```
Frame Header:
  - frame_id
  - session_id
  - timestamp
  - checksum

Zones:
  - context: Roadmap, project, state snapshots
  - actions: Audit trail entries (hash-linked)
  - thoughts: Reasoning, decisions, plans
  - audit_refs: References to audit chain (action IDs, session events)

Proof:
  - merkle_proof: Inclusion proof in Merkle tree
  - memory_hash: Frame content hash
  - audit_link: Audit chain reference
```

## Operating Rules

1. **Always start with session**: `audit_session_start` before any work
2. **Pack incrementally**: Call `memory_pack` at major checkpoints
3. **Record reasoning**: Use `thought_record` for both audit trail and memory
4. **Verify before finalizing**: Run both `audit_verify_chain` and `memory_verify`
5. **Finalize atomically**: `merkle_finalize` builds proofs for both audit and memory
6. **Bundle for archival**: `memory_bundle` creates the final prompt-ready record
7. **Cross-reference**: Use audit_refs in memory frames to link to audit trail

## Audit-Memory Bridging

When linking audit trail to memory:

1. Audit chain provides immutability and signature
2. Memory frames provide context and reasoning
3. Together: full session replay capability

Example linking:

```
Audit Action #42 (hash: abc123)
  ↓ (linked by)
Memory Frame #15 (contains thought about action #42)
  ↓ (references)
Merkle proof that includes both action and thought
```

## Recovery from Interrupted Work

If a session is interrupted:

```
1. ams_session_list to find session_id
2. ams_session_resume to continue
3. memory_bundle to rebuild prompt context
4. Continue work (new actions still audit-linked)
5. memory_pack again at completion
6. merkle_finalize to rebuild proofs
```

## Integration with Other Skills

- **colibri-audit-proof**: Core audit functionality
- **colibri-memory-context**: Core memory functionality
- **colibri-verification**: Uses audit + memory for completion proof
- **colibri-pm**: Sessions tracked with audit + memory

## Typical Requests

- "Start an audit session and set up memory archival"
- "Record this decision in both the audit trail and memory"
- "Pack the session memory for archival"
- "Verify the audit chain and memory checksums"
- "Create a bundle with full audit context for the LLM"
- "Finalize with both Merkle proof and memory archive"
- "Resume the interrupted session with full memory context"

## Common Patterns

### Full Audit + Memory Session

```
audit_session_start("colibri-work-001")
context_create()
memory_pack(["context", "action", "thought"])
[Work...]
thought_record("decision: ...")
[More work...]
memory_pack() # incremental update
audit_verify_chain()
memory_verify()
merkle_finalize()
memory_bundle(include_audit_trail: true)
```

### Resume with Memory

```
ams_session_resume("colibri-work-001")
memory_bundle() # get context
[Continue work...]
memory_pack() # record new state
merkle_finalize() # update proofs
```

## References

- Tool contracts: `data/tool-contracts/`
- See `colibri-audit-proof` for audit-specific operations
- See `colibri-memory-context` for memory-specific operations
- Colibri documentation for session lifecycle patterns
Comments 0
Latest | Hot
Please login before commenting.
Loading comments...
colibri-audit-memory

Directory Structure

SKILL.md

Report

Notice
