ctx-journal-enrich

Enrich journal entry with metadata. Use when journal entries lack frontmatter, tags, or summary for future reference.

41 stars

Best use case

ctx-journal-enrich is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Enrich journal entry with metadata. Use when journal entries lack frontmatter, tags, or summary for future reference.

Teams using ctx-journal-enrich should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/ctx-journal-enrich/SKILL.md --create-dirs "https://raw.githubusercontent.com/ActiveMemory/ctx/main/internal/assets/claude/skills/ctx-journal-enrich/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/ctx-journal-enrich/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How ctx-journal-enrich Compares

Feature / Agentctx-journal-enrichStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Enrich journal entry with metadata. Use when journal entries lack frontmatter, tags, or summary for future reference.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

Enrich a session journal entry with structured metadata.

## Before Enriching

1. **Check if locked**: a file is locked if `.state.json` has a
   `locked` date OR the frontmatter contains `locked: true`. Locked
   files must not be modified: skip them silently. Check via:
   `ctx system mark-journal --check <filename> locked`
   or look for `locked: true` in the YAML frontmatter.
2. **Check if already enriched**: check the state file via
   `ctx system mark-journal --check <filename> enriched` or read
   `.state.json` in the journal directory; confirm before overwriting

## When to Use

- When journal entries lack metadata for future reference
- After importing sessions that need categorization
- When building a searchable session archive

## When NOT to Use

- On entries that already have complete frontmatter (unless updating)
- Before normalizing entries with broken formatting
- On suggestion sessions (short auto-complete prompts; not worth enriching)

## Input

The user specifies a journal entry by partial match:
- `twinkly-stirring-kettle` (slug)
- `twinkly` (partial slug)
- `2026-01-24` (date)
- `76fe2ab9` (short ID)

Find matching files in the journal directory:
```bash
ls "$(ctx system bootstrap -q)/journal/"*.md | grep -i "<pattern>"
```

If multiple matches, show them and ask which one.
If no argument given, show recent unenriched entries by reading
`.state.json` in the journal directory and listing entries without
an `enriched` date:

```bash
# List unenriched entries using state file
CTX_DIR=$(ctx system bootstrap -q)
for f in "$CTX_DIR/journal/"*.md; do
  name=$(basename "$f")
  ctx system mark-journal --check "$name" enriched || echo "$f"
done | head -10
```

## Usage Examples

```text
/ctx-journal-enrich twinkly-stirring-kettle
/ctx-journal-enrich twinkly
/ctx-journal-enrich 2026-01-24
/ctx-journal-enrich 76fe2ab9
```

## Enrichment Tasks

Read the journal entry and extract:

### 1. Frontmatter (YAML at top of file)

```yaml
---
title: "Session title"
date: 2026-01-27
model: claude-opus-4-6  # auto-populated at import
tokens_in: 234000       # auto-populated at import
tokens_out: 89000       # auto-populated at import
type: feature
outcome: completed
topics:
  - authentication
  - caching
technologies:
  - go
  - postgresql
libraries:
  - cobra
  - fatih/color
key_files:
  - internal/auth/token.go
  - internal/db/cache.go
---
```

**Auto-populated fields** (set during `ctx journal import`, do NOT overwrite):
`date`, `time`, `project`, `session_id`, `model`, `tokens_in`, `tokens_out`, `branch`

**Type values:**

| Type            | When to use                           |
|-----------------|---------------------------------------|
| `feature`       | Building new functionality            |
| `bugfix`        | Fixing broken behavior                |
| `refactor`      | Restructuring without behavior change |
| `exploration`   | Research, learning, experimentation   |
| `debugging`     | Investigating issues                  |
| `documentation` | Writing docs, comments, README        |

**Outcome values:**

| Outcome     | Meaning                            |
|-------------|------------------------------------|
| `completed` | Goal achieved                      |
| `partial`   | Some progress, work continues      |
| `abandoned` | Stopped pursuing this approach     |
| `blocked`   | Waiting on external dependency     |

### 2. Summary

If `## Summary` says "[Add your summary...]", replace with 2-3 sentences
describing what was accomplished.

### 3. Extracted Items

Scan the conversation and extract:

**Decisions made**: link to DECISIONS.md if persisted:
```markdown
## Decisions
- Used Redis for caching ([D12](../DECISIONS.md#d12))
- Chose JWT over sessions (not yet persisted)
```

**Learnings discovered**: link to LEARNINGS.md if persisted:
```markdown
## Learnings
- Token refresh requires cache invalidation ([L8](../LEARNINGS.md#l8))
- Go's defer runs LIFO (new insight)
```

**Tasks completed/created**:
```markdown
## Tasks
- [x] Implement caching layer
- [ ] Add cache metrics (created this session)
```

## Process

1. Find and read the journal file
2. Analyze the conversation
3. Propose enrichment (type, topics, outcome)
4. Ask user for confirmation/adjustments
5. Show diff and write if approved
6. **Mark enriched** in the state file:
   ```bash
   ctx system mark-journal <filename> enriched
   ```
7. Remind user to rebuild: `ctx journal site --build` or `make journal`

Related Skills

ctx-journal-normalize

41
from ActiveMemory/ctx

Normalize journal source markdown for clean rendering. Use after journal site shows rendering issues: fence nesting, metadata formatting, broken lists.

ctx-journal-enrich-all

41
from ActiveMemory/ctx

Full journal pipeline: import unimported sessions, then batch-enrich all unenriched entries. Use when the user says 'process the journal' or to catch up on the backlog.

ctx-architecture-enrich

41
from ActiveMemory/ctx

Enrich architecture artifacts with code intelligence data. Takes existing /ctx-architecture output as baseline, verifies and quantifies with GitNexus MCP (blast radius, execution flows, domain clustering, registration sites). Run after /ctx-architecture, not instead of it.

ctx-verify

41
from ActiveMemory/ctx

Verify before claiming completion. Use before saying work is done, tests pass, or builds succeed.

ctx-skill-creator

41
from ActiveMemory/ctx

Create, improve, test, and deploy skills. Full skill lifecycle from intent to working skill file.

ctx-sanitize-permissions

41
from ActiveMemory/ctx

Audit tool permissions for dangerous or overly broad entries. Use to ensure safe agent configuration.

ctx-recall

41
from ActiveMemory/ctx

Browse session history. Use when referencing past discussions or finding context from previous work.

ctx-prompt

41
from ActiveMemory/ctx

Apply, list, and manage saved prompt templates from .context/prompts/. Use when the user asks to apply, list, or create a reusable template like code-review or refactor.

ctx-import-plans

41
from ActiveMemory/ctx

Import plan files into project specs directory. Use to convert external plans into project-tracked specs.

ctx-compact

41
from ActiveMemory/ctx

Archive completed tasks and trim context. Use when context files are growing large.

ctx-check-links

41
from ActiveMemory/ctx

Audit docs for dead links. Use before releases, after restructuring docs, or when running a documentation audit.

ctx-add-task

41
from ActiveMemory/ctx

Add a task. Use when follow-up work is identified or when breaking down complex work into subtasks.