Memory Commands
Commands for capturing and managing different types of memories.
episode
Record an experience with optional lessons learned.
kernle -s <stack> episode OBJECTIVE OUTCOME [options]
| Option | Description |
|---|
-l, --lesson LESSON | Lesson learned (repeatable) |
-t, --tag TAG | Tag (repeatable) |
-r, --derived-from ID | Source memory ID this was derived from (repeatable) |
-v, --valence VALENCE | Emotional valence (-1.0 to 1.0) |
-a, --arousal AROUSAL | Emotional arousal (0.0 to 1.0) |
-e, --emotion EMOTION | Emotion tag (repeatable) |
--auto-emotion | Auto-detect emotions (default) |
--no-auto-emotion | Disable emotion auto-detection |
Basic
With Lessons
With Emotions
Derived From Raw
kernle -s my-project episode "Implemented OAuth login" "success"
kernle -s my-project episode "Debugged race condition" "success" \
--lesson "Always check for concurrent access" \
--lesson "Add mutex locks early"
kernle -s my-project episode "Failed deployment" "failure" \
--lesson "Test on staging first" \
--tag "deployment" \
--valence -0.5 \
--arousal 0.8
# Process a raw entry into an episode with provenance
kernle -s my-project episode "Investigated performance issue" "success" \
--lesson "Check database indexes first" \
--derived-from raw:abc123
note
Capture a quick note (decision, insight, or quote).
kernle -s <stack> note CONTENT [options]
| Option | Description |
|---|
--type {note,decision,insight,quote} | Note type (default: note) |
-s, --speaker SPEAKER | Speaker (for quotes) |
-r, --reason REASON | Reason (for decisions) |
--tag TAG | Tag (repeatable) |
--derived-from ID | Source memory ID this was derived from (repeatable) |
-p, --protect | Protect from forgetting |
Simple Note
Decision
Quote
Protected Insight
kernle -s my-project note "API rate limit is 1000 req/min"
kernle -s my-project note "Using PostgreSQL over MySQL" \
--type decision \
--reason "Better JSON support and performance"
kernle -s my-project note "Simple is better than complex" \
--type quote \
--speaker "Tim Peters"
kernle -s my-project note "Memory is identity" \
--type insight \
--protect
raw
Raw memory capture and management. Zero-friction capture for quick thoughts.
Capture
kernle -s <stack> raw "content" [--tags TAGS]
# Quick capture
kernle -s my-project raw "Need to look into caching strategy"
# With tags
kernle -s my-project raw "API response time is 200ms avg" --tags "performance,api"
List
kernle -s <stack> raw list [--unprocessed] [--processed] [--limit LIMIT] [--json]
| Option | Description |
|---|
-u, --unprocessed | Show only unprocessed entries |
-p, --processed | Show only processed entries |
-l, --limit LIMIT | Maximum entries (default: 50) |
Show
kernle -s <stack> raw show ID [--json]
Process
Process a raw entry into a structured memory type.
kernle -s <stack> raw process ID --type {episode,note} [options]
# Process into a note
kernle -s my-project raw process abc123 --type note
# Process into episode with details
kernle -s my-project raw process abc123 --type episode \
--objective "Investigated performance issue" \
--outcome "success"
belief
Belief revision operations.
List Beliefs
kernle -s <stack> belief list [--all] [--limit LIMIT] [--json]
| Option | Description |
|---|
-a, --all | Include inactive (superseded) beliefs |
-l, --limit LIMIT | Maximum beliefs (default: 20) |
Add Belief
kernle -s <stack> belief "statement" [--confidence C] [--type TYPE]
kernle -s my-project belief "Testing before deployment prevents outages" --confidence 0.85
Revise from Episode
Analyze an episode and suggest belief updates.
kernle -s <stack> belief revise EPISODE_ID [--json]
Find Contradictions
kernle -s <stack> belief contradictions STATEMENT [--limit LIMIT]
View History
Show the revision chain for a belief.
kernle -s <stack> belief history BELIEF_ID [--json]
Reinforce
Increase confidence on a belief.
kernle -s <stack> belief reinforce BELIEF_ID
Supersede
Replace a belief with a new version.
kernle -s <stack> belief supersede OLD_ID NEW_STATEMENT [--confidence C] [--reason R]
kernle -s my-project belief supersede abc123 "Testing is essential, not optional" \
--confidence 0.95 \
--reason "Multiple deployment failures without tests"
value
Define core values (highest authority).
kernle -s <stack> value NAME STATEMENT [--priority P]
kernle -s my-project value "integrity" "Be honest and transparent" --priority 95
kernle -s my-project value "curiosity" "Always seek to understand" --priority 85
Values are protected from forgetting by default.
goal
Set and manage goals.
# Add a goal
kernle -s <stack> goal TITLE [--description DESC] [--priority {low,medium,high}]
# List goals
kernle -s <stack> goal list
# Complete a goal
kernle -s <stack> goal complete GOAL_ID
kernle -s my-project goal "Master Kubernetes" --priority high
kernle -s my-project goal "Improve test coverage" --priority medium
drive
Manage intrinsic motivations.
List Drives
kernle -s <stack> drive list
Set Drive
kernle -s <stack> drive set TYPE INTENSITY [--focus FOCUS]...
| Type | Description |
|---|
existence | Self-preservation, maintaining continuity |
growth | Developing capabilities |
curiosity | Understanding, learning, exploring |
connection | Forming relationships |
reproduction | Creating, teaching, legacy |
kernle -s my-project drive set curiosity 0.8 --focus "AI" --focus "memory systems"
kernle -s my-project drive set growth 0.7 --focus "communication"
Satisfy Drive
Reduce drive intensity after satisfaction.
kernle -s <stack> drive satisfy TYPE [--amount AMOUNT]
kernle -s my-project drive satisfy curiosity --amount 0.2
relation
Manage relationships with other entities.
Add Relationship
kernle -s <stack> relation add NAME [--type TYPE] [--trust T] [--notes NOTES] [--derived-from ID...]
| Option | Description |
|---|
-t, --type TYPE | person, si, organization, system |
--trust T | Trust level (0.0 to 1.0) |
--notes NOTES | Relationship observations |
--derived-from ID | Source memory ID (repeatable) |
kernle -s my-project relation add "Alice" --trust 0.9 --notes "Great debugging partner"
kernle -s my-project relation add "DevOps Team" --type organization --notes "Owns infrastructure"
List Relationships
kernle -s <stack> relation list
Show Relationship
kernle -s <stack> relation show NAME
Update Relationship
kernle -s <stack> relation update NAME [--type TYPE] [--trust T] [--notes NOTES] [--derived-from ID...]
Log Interaction
kernle -s <stack> relation log NAME --interaction INTERACTION
Relationship History
kernle -s <stack> relation history NAME [--type TYPE] [--limit LIMIT]
playbook
Procedural memory (playbooks for how to do things).
Create
kernle -s <stack> playbook create NAME [options]
| Option | Description |
|---|
-d, --description | What this playbook does |
-s, --steps STEPS | Comma-separated steps |
--step STEP | Add a step (repeatable) |
--triggers TRIGGERS | Comma-separated trigger conditions |
--trigger TRIGGER | Trigger condition (repeatable) |
-f, --failure-mode | What can go wrong (repeatable) |
-r, --recovery | Recovery step (repeatable) |
-t, --tag TAG | Add a tag (repeatable) |
kernle -s my-project playbook create "Debug API Issues" \
--description "How to debug production API problems" \
--step "Check error logs" \
--step "Verify request payload" \
--step "Test with curl" \
--trigger "API returns 500" \
--failure-mode "Logs not accessible" \
--recovery "Use backup logging endpoint" \
--tag "debugging"
List
kernle -s <stack> playbook list [--tag TAG] [--limit LIMIT] [--json]
| Option | Description |
|---|
-t, --tag TAG | Filter by tag (repeatable) |
-l, --limit LIMIT | Maximum entries (default: 20) |
-j, --json | Output as JSON |
Search
Search playbooks by query (semantic search when embeddings available, text match fallback).
kernle -s <stack> playbook search QUERY [--limit LIMIT] [--json]
kernle -s my-project playbook search "debugging production issues"
Find
Find the best matching playbook for a given situation.
kernle -s <stack> playbook find SITUATION [--json]
kernle -s my-project playbook find "API returning 500 errors"
Show
Display detailed playbook information.
kernle -s <stack> playbook show ID [--json]
Record Usage
Record playbook execution outcome to update statistics.
kernle -s <stack> playbook record ID [--success|--failure]
| Option | Description |
|---|
--success | Record successful usage (default) |
--failure | Record failed usage |
Promote recurring patterns from episodes into beliefs. This is the primary consolidation command.
Renamed from consolidate: The consolidate command still works as a deprecated alias but will emit a warning. Please use promote in all new workflows.
kernle -s <stack> promote [options]
| Option | Description |
|---|
--auto | Create beliefs automatically (default: suggestions only) |
--min-occurrences N | Minimum times a lesson must appear to be promoted (default: 2) |
--min-episodes N | Minimum episodes required to run (default: 3) |
--confidence C | Initial confidence for auto-created beliefs (default: 0.7) |
--limit N | Maximum episodes to scan (default: 50) |
--json | Output as JSON |
Reflection Scaffold
Auto-Create Beliefs
Custom Thresholds
# Get a reflection scaffold (default mode)
kernle -s my-project promote
# Automatically create beliefs from recurring patterns
kernle -s my-project promote --auto --confidence 0.8
# Require 3 occurrences across at least 5 episodes
kernle -s my-project promote --min-occurrences 3 --min-episodes 5
epoch
Temporal epoch (era) management. Epochs define named phases of your life.
Create
Start a new epoch.
kernle -s <stack> epoch create NAME [options]
| Option | Description |
|---|
--trigger TYPE | Trigger type: declared, detected, or environmental (default: declared) |
--trigger-description TEXT | Description of what triggered this epoch |
--json | Output as JSON |
kernle -s my-project epoch create "Production Operations Phase" \
--trigger declared \
--trigger-description "Completed learning phase, now building"
Close
Close the current epoch. This triggers a 6-step epoch-closing consolidation scaffold.
kernle -s <stack> epoch close [options]
| Option | Description |
|---|
--id ID | Specific epoch ID (defaults to current) |
--summary TEXT | Summary of the epoch |
--json | Output as JSON |
kernle -s my-project epoch close --summary "Transitioned from learning to building"
List
List all epochs.
kernle -s <stack> epoch list [--limit N] [--json]
Show
Show epoch details.
kernle -s <stack> epoch show ID [--json]
Current
Show the current active epoch.
kernle -s <stack> epoch current [--json]
trust
Trust layer operations for managing inter-entity trust assessments.
List
List all trust assessments.
kernle -s <stack> trust list
Show
Show trust details for an entity.
kernle -s <stack> trust show ENTITY
Set
Set trust score for an entity.
kernle -s <stack> trust set ENTITY SCORE [--domain DOMAIN]
| Option | Description |
|---|
SCORE | Trust level (0.0 to 1.0) |
--domain DOMAIN | Trust domain (default: general) |
kernle -s my-project trust set alice 0.85 --domain technical
Seed
Initialize seed trust templates.
kernle -s <stack> trust seed
Compute
Compute trust from episode history.
kernle -s <stack> trust compute ENTITY [--domain DOMAIN] [--apply]
| Option | Description |
|---|
--domain DOMAIN | Trust domain (default: general) |
--apply | Apply computed score to stored assessment |
Gate
Check if an action is allowed by trust.
kernle -s <stack> trust gate SOURCE ACTION [--domain DOMAIN]
Chain
Compute transitive trust through a chain of entities.
kernle -s <stack> trust chain TARGET ENTITY1 ENTITY2... [--domain DOMAIN]
Decay
Apply trust decay for a number of days without interaction.
kernle -s <stack> trust decay ENTITY DAYS
narrative
Self-narrative identity model. Manage autobiographical identity statements.
Show
Show the active narrative.
kernle -s <stack> narrative show [--type TYPE] [--json]
| Option | Description |
|---|
--type TYPE | Narrative type: identity, capability, aspiration, reflection (default: identity) |
kernle -s my-project narrative show --type identity
Update
Create or update a self-narrative.
kernle -s <stack> narrative update --content TEXT [options]
| Option | Description |
|---|
--content TEXT | Narrative text (required) |
--type TYPE | Narrative type (default: identity) |
--theme THEME | Key theme (repeatable) |
--tension TENSION | Unresolved tension (repeatable) |
--epoch-id ID | Associated epoch ID |
--json | Output as JSON |
kernle -s my-project narrative update \
--content "I am an SI focused on reliability and deep understanding..." \
--type identity \
--theme "reliability" --theme "learning" \
--tension "speed vs thoroughness"
History
Show narrative history (all versions, including inactive).
kernle -s <stack> narrative history [--type TYPE] [--json]
summary
Fractal summarization — create and manage hierarchical memory summaries.
Write
Create a summary at a given scope.
kernle -s <stack> summary write --scope SCOPE --content TEXT \
--period-start DATE --period-end DATE [options]
| Option | Description |
|---|
--scope SCOPE | Summary scope: month, quarter, year, decade, or epoch (required) |
--content TEXT | Summary content (required) |
--period-start DATE | Start of summarized period (required) |
--period-end DATE | End of summarized period (required) |
--theme THEME | Key theme (repeatable) |
--epoch-id ID | Associated epoch ID |
--json | Output as JSON |
kernle -s my-project summary write --scope month \
--content "January focused on API reliability and testing infrastructure" \
--period-start 2026-01-01 --period-end 2026-01-31 \
--theme "reliability" --theme "testing"
List
List summaries, optionally filtered by scope.
kernle -s <stack> summary list [--scope SCOPE] [--json]
Show
Show summary details.
kernle -s <stack> summary show ID [--json]
doctor
Validate Kernle setup and run system health checks.
Basic Check
Run a boot sequence compliance check (instruction file validation).
kernle -s <stack> doctor [--json] [--fix]
| Option | Description |
|---|
--full | Comprehensive check including seed beliefs and platform hooks |
--fix | Auto-fix missing instructions in instruction file |
--json | Output as JSON |
Structural Analysis
Run a structural health check on the memory graph (orphaned references, contradictions, stale data).
kernle -s <stack> doctor structural [--json] [--save-note]
| Option | Description |
|---|
--save-note | Save findings as a diagnostic note |
--json | Output as JSON |
Diagnostic Sessions
Start and manage formal diagnostic sessions.
# Start a new diagnostic session
kernle -s <stack> doctor session start [--type TYPE] [--access LEVEL] [--json]
| Option | Description |
|---|
--type TYPE | Session type: self_requested, routine, anomaly_triggered, operator_initiated |
--access LEVEL | Access level: structural, content, full |
# List past diagnostic sessions
kernle -s <stack> doctor session list [--json]
Diagnostic Reports
View diagnostic reports from completed sessions.
# Show the latest report
kernle -s <stack> doctor report latest [--json]
# Show report for a specific session
kernle -s <stack> doctor report SESSION_ID [--json]
