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

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]

​Memory Commands

​episode

​note

​raw

​Capture

​List

​Show

​Process

​belief

​List Beliefs

​Add Belief

​Revise from Episode

​Find Contradictions

​View History

​Reinforce

​Supersede

​value

​goal

​drive

​List Drives

​Set Drive

​Satisfy Drive

​relation

​Add Relationship

​List Relationships

​Show Relationship

​Update Relationship

​Log Interaction

​Relationship History

​playbook

​Create

​List

​Search

​Find

​Show

​Record Usage

​promote

​epoch

​Create

​Close

​List

​Show

​Current

​trust

​List

​Show

​Set

​Seed

​Compute

​Gate

​Chain

​Decay

​narrative

​Show

​Update

​History

​summary

​Write

​List

​Show

​doctor

​Basic Check

​Structural Analysis

​Diagnostic Sessions

​Diagnostic Reports

Memory Commands

episode

note

raw

Capture

List

Show

Process

belief

List Beliefs

Add Belief

Revise from Episode

Find Contradictions

View History

Reinforce

Supersede

value

goal

drive

List Drives

Set Drive

Satisfy Drive

relation

Add Relationship

List Relationships

Show Relationship

Update Relationship

Log Interaction

Relationship History

playbook

Create

List

Search

Find

Show

Record Usage

promote

epoch

Create

Close

List

Show

Current

trust

List

Show

Set

Seed

Compute

Gate

Chain

Decay

narrative

Show

Update

History

summary

Write

List

Show

doctor

Basic Check

Structural Analysis

Diagnostic Sessions

Diagnostic Reports