agentleFS
Kastalien-ResearchKastalien-Research/thoughtbox/.agents/skills/thoughtbox-session-review/SKILL.md

thoughtbox:session-review

Skill64 starsChanged 5 months agoMITView on GitHub

Analyze completed Thoughtbox sessions to extract patterns, anti-patterns, and learnings for the knowledge graph. This is the learning loop that makes Thoughtbox improve over time. Use after completing a reasoning session, when reviewing past sessions for insights, or when you want to assess reasoning quality. Triggers on "review session", "what did I learn", "extract insights", "analyze reasoning", "session retrospective", or proactively after any significant session completes.

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 3 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    After any session >15 thoughts

    line 178
  2. Distinctive:

    After sessions that involved significant decisions

    line 179
  3. Distinctive:

    After sessions with high revision rates (something kept going wrong)

    line 180

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Thoughtbox Session Review

Sessions are write-once without review. This skill turns completed sessions into reusable knowledge by identifying what worked, what didn't, and what to carry forward.

Workflow

Phase 1: Retrieve and Measure

Find the session and get structural metrics:

// thoughtbox_execute — find the session
async () => {
  // By ID:
  const session = await tb.session.get("session-uuid");
  // Or find latest:
  const list = await tb.session.list({ limit: 1 });
  return list;
}
// Get structural metrics
async () => {
  const analysis = await tb.session.analyze("session-uuid");
  return analysis;
  // Returns: linearityScore, revisionRate, maxDepth, thoughtDensity,
  //          critiqueRequests, hasConvergence, isComplete
}

Interpret the metrics:

MetricHigh value meansLook for
revisionRate > 0.15Many course correctionsAnti-patterns — what kept going wrong?
linearityScore < 0.7Heavy branchingExploration strategies — were branches productive?
hasConvergence = trueBranches resolvedDecision patterns — how was the choice made?
isComplete = falseSession abandonedWhy? Context loss? Stuck? Deprioritized?

Phase 2: Identify Key Moments

Retrieve the full session and scan for signal thoughts:

async () => {
  const session = await tb.session.get("session-uuid");
  return session.thoughts;
}

Scan for these moment types:

  • Pivots — reasoning direction changed. Look for: "actually", "wait", "on second thought", significant topic shift
  • Decisions — uncertainty resolved. Look for: "choosing", "decided", "going with", comparison conclusions
  • Insights — synthesis occurred. Look for: "this means", "the pattern is", "I see now", connections between ideas
  • Revisions — corrections made. Check isRevision: true field
  • Branch points — exploration diverged. Check branchFromThought field

Rate each moment:

  • Impact (1-10): How much did this thought influence the outcome?
  • Novelty (1-10): Was this a new approach or standard reasoning?
  • Transferability (1-10): Could this pattern apply to other problems?

Phase 3: Extract Learnings

Feed identified moments to the extraction system:

async () => {
  return await tb.session.extractLearnings("session-uuid",
    [
      {
        thoughtNumber: 5,
        type: "decision",
        significance: 8,
        summary: "Chose hybrid caching approach over pure Redis"
      },
      {
        thoughtNumber: 12,
        type: "insight",
        significance: 9,
        summary: "Cache invalidation can piggyback on existing event bus"
      },
      {
        thoughtNumber: 8,
        type: "pivot",
        significance: 6,
        summary: "Abandoned single-cache approach after discovering TTL limitations"
      }
    ],
    ["pattern", "anti-pattern", "signal"]
  );
}

Phase 4: Persist to Knowledge Graph

For each extracted learning, create a durable knowledge entity:

async () => {
  // Pattern becomes an Insight entity
  const entity = await tb.knowledge.createEntity({
    name: "event-bus-cache-invalidation",
    type: "Insight",
    label: "Cache invalidation via existing event bus",
    properties: {
      domain: "caching",
      source_session: "session-uuid",
      summary: "Rather than building a separate invalidation mechanism, piggyback on the existing event bus"
    }
  });

  // Connect to related concepts
  await tb.knowledge.createRelation({
    from_id: entity.id,
    to_id: "existing-event-bus-entity-id",
    relation_type: "BUILDS_ON"
  });
}

For anti-patterns, add observations explaining what went wrong:

async () => {
  const entity = await tb.knowledge.createEntity({
    name: "single-cache-ttl-limitation",
    type: "Insight",
    label: "Single-cache approach fails with heterogeneous TTLs",
    properties: { domain: "caching", type: "anti-pattern" }
  });

  await tb.knowledge.addObservation({
    entity_id: entity.id,
    content: "Discovered in session XYZ: a single Redis instance can't efficiently handle objects with vastly different TTL requirements. The eviction policy conflicts."
  });
}

Phase 5: Report

Present a summary to the user:

## Session Review: [title]

### Metrics
- Thoughts: N | Branches: N | Revisions: N
- Linearity: X | Revision rate: X%
- Convergence: yes/no | Complete: yes/no

### Key Moments
1. [Thought N] **Decision**: Chose hybrid caching (impact: 8)
2. [Thought M] **Insight**: Event bus for invalidation (impact: 9)
3. [Thought K] **Pivot**: Abandoned single-cache (impact: 6)

### Patterns Extracted
- Event bus cache invalidation (persisted as knowledge entity)

### Anti-Patterns Identified
- Single-cache with heterogeneous TTLs (persisted with observation)

### Knowledge Graph Updates
- Created N entities, M relations, K observations

When to Review

  • After any session >15 thoughts
  • After sessions that involved significant decisions
  • After sessions with high revision rates (something kept going wrong)
  • Periodically, to maintain the learning loop

See thoughtbox://session-analysis-guide for the full qualitative analysis process.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.