episode-start

Initialize a Rust learning episode with TaskContext and persist it to Turso.

11|Updated Nov 5, 2025
One-click install
npx skills add https://github.com/d-o-hub/rust-self-learning-memory --skill episode-start
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: episode-start
Source: https://github.com/d-o-hub/rust-self-learning-memory/tree/main/.claude/skills/episode-start
Command: npx skills add https://github.com/d-o-hub/rust-self-learning-memory --skill episode-start

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill starts a new learning episode with structured context so the memory system can learn from execution patterns.

Core Features & Use Cases

  • Context preparation: language, domain, and tags captured for episode context.
  • Episode creation: robust call to start_episode with task description and context.
  • Logging readiness: initialize step logging for future actions.

Quick Start

Create a TaskContext with language "rust", domain "storage", and relevant tags; then call start_episode with a concise task description.

Frequently Asked Questions about episode-start

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I initialize a learning episode to track execution patterns in Rust?

Initialize a learning episode by creating a TaskContext with language 'rust', selecting a domain like storage or patterns, then calling SelfLearningMemory::start_episode() with your task description. The Skill prepares step logging and persists context to Turso while caching in redb for pattern tracking across executions.

What context do I need to prepare before starting an episode?

Prepare a TaskContext specifying language as 'rust', choose a domain from storage, patterns, retrieval, embedding, testing, or ci, and add relevant tags. This structured context enables the memory system to learn from execution patterns in your specific domain.

Can I use this Skill with async Rust and Tokio workflows?

Yes, the Skill is designed for Rust/Tokio/async context. It integrates with async task initialization, letting you start learning episodes within async workflows to track execution patterns across asynchronous operations.

How does episode-start fit into a self-learning memory system?

episode-start initializes new episode records in a self-learning memory system that learns from execution patterns. By capturing domain, language, and tags upfront, it enables downstream analysis and retrieval of patterns across storage, testing, CI, and other domains.

What happens to my episode context after I start an episode?

After calling start_episode(), the context is persisted to Turso for durability and cached in redb for fast retrieval. An episode_id is stored and step logging is initialized, allowing you to track and learn from subsequent execution steps.