episode-log-steps

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Episode Log Steps

任务片段执行步骤日志

Log execution steps during episode execution for detailed tracking and learning.

在任务片段执行期间记录执行步骤，以实现详细追踪与学习。

Purpose

目的

Record individual execution steps to build a complete picture of task execution for pattern learning.

记录单个执行步骤，构建任务执行的完整视图，用于模式学习。

When to Log Steps

何时记录步骤

Tool usage: Each time a significant tool is used
Decision points: When making architectural or implementation choices
Error handling: When encountering and resolving errors
Milestones: Key progress points (test passing, module complete)

工具使用：每次使用重要工具时
决策点：进行架构或实现方案选择时
错误处理：遇到并解决错误时
里程碑：关键进度节点（测试通过、模块完成）

Step Structure

步骤结构

rust

pub struct ExecutionStep {
    pub tool: String,           // Tool/action used
    pub action: String,         // Description of action
    pub latency_ms: u64,        // Time taken
    pub tokens: Option<u32>,    // Tokens used (if applicable)
    pub success: bool,          // Whether step succeeded
    pub observation: String,    // Outcome/observations
}

rust

pub struct ExecutionStep {
    pub tool: String,           // Tool/action used
    pub action: String,         // Description of action
    pub latency_ms: u64,        // Time taken
    pub tokens: Option<u32>,    // Tokens used (if applicable)
    pub success: bool,          // Whether step succeeded
    pub observation: String,    // Outcome/observations
}

Logging Guidelines

记录指南

1. Batch When Appropriate

1. 合理批量记录

Don't log every tiny operation
Batch related steps when many occur quickly
Log significant operations individually

不要记录每一个微小操作
当多个相关操作快速连续发生时，进行批量记录
单独记录重要操作

2. Include Context

2. 包含上下文信息

Tool: cargo, rustfmt, clippy, git, etc.
Action: Specific command or operation
Observation: Result, output summary, or error

工具：cargo, rustfmt, clippy, git, etc.
操作：具体命令或操作内容
结果：执行结果、输出摘要或错误信息

3. Track Performance

3. 追踪性能数据

Record latency for slow operations
Note token usage for LLM calls
Mark success/failure clearly

记录慢操作的耗时
记录LLM调用的token使用量
清晰标记操作成功/失败状态

Examples

示例

Build Step

构建步骤

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "build --all".to_string(),
    latency_ms: 12500,
    tokens: None,
    success: true,
    observation: "Build successful, 0 warnings".to_string(),
};
memory.log_step(episode_id, step).await?;

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "build --all".to_string(),
    latency_ms: 12500,
    tokens: None,
    success: true,
    observation: "Build successful, 0 warnings".to_string(),
};
memory.log_step(episode_id, step).await?;

Test Step

测试步骤

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "test --test integration_test".to_string(),
    latency_ms: 3200,
    tokens: None,
    success: false,
    observation: "2 tests failed: test_batch_insert, test_concurrent_writes".to_string(),
};
memory.log_step(episode_id, step).await?;

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "test --test integration_test".to_string(),
    latency_ms: 3200,
    tokens: None,
    success: false,
    observation: "2 tests failed: test_batch_insert, test_concurrent_writes".to_string(),
};
memory.log_step(episode_id, step).await?;

Code Generation Step

代码生成步骤

rust

let step = ExecutionStep {
    tool: "claude".to_string(),
    action: "generate async batch implementation".to_string(),
    latency_ms: 4500,
    tokens: Some(2800),
    success: true,
    observation: "Generated batch.rs with async Tokio patterns".to_string(),
};
memory.log_step(episode_id, step).await?;

rust

let step = ExecutionStep {
    tool: "claude".to_string(),
    action: "generate async batch implementation".to_string(),
    latency_ms: 4500,
    tokens: Some(2800),
    success: true,
    observation: "Generated batch.rs with async Tokio patterns".to_string(),
};
memory.log_step(episode_id, step).await?;

Error Resolution Step

错误修复步骤

rust

let step = ExecutionStep {
    tool: "clippy".to_string(),
    action: "check --all".to_string(),
    latency_ms: 1500,
    tokens: None,
    success: true,
    observation: "Fixed 3 warnings: unused imports, unnecessary clone".to_string(),
};
memory.log_step(episode_id, step).await?;

rust

let step = ExecutionStep {
    tool: "clippy".to_string(),
    action: "check --all".to_string(),
    latency_ms: 1500,
    tokens: None,
    success: true,
    observation: "Fixed 3 warnings: unused imports, unnecessary clone".to_string(),
};
memory.log_step(episode_id, step).await?;

Batching Strategy

批量记录策略

When multiple related steps occur in a burst (e.g., fixing multiple test failures):

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "fix 5 test failures in batch_test.rs".to_string(),
    latency_ms: 18000,
    tokens: Some(3500),
    success: true,
    observation: "Fixed: test_batch_insert (await missing), test_concurrent (lock order), test_timeout (semaphore added)".to_string(),
};
memory.log_step(episode_id, step).await?;

当多个相关操作集中发生时（例如修复多个测试失败）：

rust

let step = ExecutionStep {
    tool: "cargo".to_string(),
    action: "fix 5 test failures in batch_test.rs".to_string(),
    latency_ms: 18000,
    tokens: Some(3500),
    success: true,
    observation: "Fixed: test_batch_insert (await missing), test_concurrent (lock order), test_timeout (semaphore added)".to_string(),
};
memory.log_step(episode_id, step).await?;

Notes

注意事项

Steps are stored as JSON array in episode record
Use clear, actionable observations
Include error messages when relevant
Keep observation strings concise but informative

步骤会以JSON数组形式存储在任务片段记录中
使用清晰、可操作的结果描述
相关时包含错误信息
保持结果描述简洁且信息丰富