tlc-claude-code 1.8.5 → 2.1.0

package/.claude/commands/tlc/guard.md

@@ -0,0 +1,191 @@
+# /tlc:guard - TLC Process Guard
+
+Validates that TLC planning and building were done properly. Catches process shortcuts before they become problems.
+
+## What This Does
+
+1. **Checks planning quality** — phase files exist, tasks are properly broken down, acceptance criteria present
+2. **Checks build quality** — test-first was followed, coverage exists, no implementation without tests
+3. **Reports violations** with specific fixes
+4. **Optionally auto-fixes** structural issues
+
+Run this before marking anything as "done."
+
+## Usage
+
+```
+/tlc:guard
+/tlc:guard plan 42      # check planning for phase 42
+/tlc:guard build 42     # check build compliance for phase 42
+/tlc:guard --fix        # auto-fix what can be fixed
+```
+
+## Planning Guard
+
+### What Gets Checked
+
+Read `.planning/phases/{N}-PLAN.md` and validate:
+
+**Structure (required):**
+- [ ] Phase file exists at `.planning/phases/{N}-PLAN.md`
+- [ ] Has a clear title with phase number
+- [ ] Has a goal/objective section
+- [ ] Has task breakdown (not just a wall of text)
+
+**Task Quality (required):**
+- [ ] Each task has a checkbox marker (`[ ]`, `[>@user]`, or `[x@user]`)
+- [ ] Tasks are small enough to implement in one sitting (no mega-tasks)
+- [ ] Tasks have acceptance criteria or clear "done" definition
+- [ ] Tasks are ordered by dependency (prerequisites first)
+
+**Completeness (recommended):**
+- [ ] Technical approach is specified (not just "build X")
+- [ ] File paths are mentioned where relevant
+- [ ] Edge cases are considered
+- [ ] No vague tasks like "improve performance" or "fix bugs" (too broad)
+
+### Planning Violations
+
+```
+/tlc:guard plan 42
+
+Checking phase 42 plan...
+
+❌ VIOLATIONS:
+1. Task 3 has no acceptance criteria: "Implement auth module"
+   → Add: what endpoints, what auth method, what response format?
+
+2. Task 5 is too broad: "Handle all error cases"
+   → Break into specific error scenarios
+
+3. No dependency ordering — Task 4 depends on Task 2 but comes first
+
+⚠️ WARNINGS:
+1. No file paths mentioned — harder to review later
+2. Task 1 and Task 6 look like they could be one task
+
+Fix these before running /tlc:build.
+```
+
+## Build Guard
+
+### What Gets Checked
+
+For a phase that's been (partially) built, verify TLC compliance:
+
+**Test-First (critical):**
+- [ ] Test files exist for all implemented source files
+- [ ] Git log shows test commits BEFORE implementation commits (check timestamps and diffs)
+- [ ] No source file was added without a corresponding test file in the same or earlier commit
+
+**Coverage:**
+- [ ] Run tests and check they all pass
+- [ ] Coverage meets threshold from `.tlc.json` (default 80%)
+- [ ] New code specifically has coverage (not just overall project average)
+
+**Code Quality:**
+- [ ] No `console.log` debugging left in production code
+- [ ] No `TODO` or `FIXME` comments that should be tracked as tasks
+- [ ] No hardcoded secrets, URLs, or credentials (check for patterns)
+- [ ] No skipped tests (`.skip`, `xit`, `xdescribe`)
+
+**Process:**
+- [ ] Phase plan exists and tasks are checked off
+- [ ] Implementation matches what was planned (no scope creep)
+- [ ] Commits reference the phase/task they belong to
+
+### Build Violations
+
+```
+/tlc:guard build 42
+
+Checking phase 42 build compliance...
+
+❌ VIOLATIONS:
+1. TEST-FIRST BREACH: server/lib/auth/auth.service.js was committed
+   BEFORE server/lib/auth/auth.test.js
+   → Commits: abc123 (service) came before def456 (test)
+
+2. MISSING TEST: server/lib/auth/token-utils.js has no test file
+   → Expected: server/lib/auth/token-utils.test.js
+
+3. SKIPPED TEST: server/lib/auth/auth.test.js line 45 — test.skip()
+   → Either fix the test or remove it
+
+⚠️ WARNINGS:
+1. console.log found in server/lib/auth/auth.service.js:23
+2. TODO comment in server/lib/auth/auth.service.js:67
+3. Coverage for new files: 72% (below 80% threshold)
+
+Run /tlc:autofix to resolve skipped tests.
+```
+
+## Auto-Fix Mode
+
+With `--fix`, the guard can resolve some issues automatically:
+
+**Can auto-fix:**
+- Remove `console.log` statements (non-intentional ones)
+- Convert `TODO`/`FIXME` to tasks in the phase plan
+- Create skeleton test files for untested source files
+- Fix task checkbox formatting in plan files
+
+**Cannot auto-fix (reports only):**
+- Test-first order violations (that ship has sailed)
+- Missing acceptance criteria (needs human input)
+- Scope creep (needs human judgment)
+- Low coverage (needs more test cases written)
+
+## Combined Guard
+
+Running `/tlc:guard` without arguments checks everything for the current/latest phase:
+
+```
+/tlc:guard
+
+Detecting current phase... Phase 42: Auth Module
+
+=== PLANNING GUARD ===
+✅ Plan structure: OK
+✅ Task breakdown: 6 tasks, all with criteria
+⚠️ Task 5 seems broad — consider splitting
+
+=== BUILD GUARD ===
+✅ Test-first: All tests committed before implementation
+✅ Coverage: 87% (above 80% threshold)
+❌ 1 skipped test found
+⚠️ 2 console.log statements
+
+Overall: 1 violation, 3 warnings
+
+Run /tlc:guard --fix to auto-resolve what's possible.
+```
+
+## Integration with Other Commands
+
+This guard should be consulted:
+- **Before `/tlc:verify`** — don't verify code that wasn't built properly
+- **Before `/tlc:complete`** — don't complete a milestone with process violations
+- **After `/tlc:build`** — as a final check before moving on
+- **After `/tlc:plan`** — validate the plan before building
+
+## Example Full Flow
+
+```
+/tlc:plan 42          # Create the plan
+/tlc:guard plan 42    # Validate the plan ← catches bad plans early
+/tlc:build 42         # Build test-first
+/tlc:guard build 42   # Validate the build ← catches process shortcuts
+/tlc:e2e-verify       # Visual verification
+/tlc:watchci          # CI verification
+/tlc:verify 42        # Human acceptance
+/tlc:complete         # Mark done
+```
+
+## When to Use
+
+- After planning, before building
+- After building, before verification
+- When you suspect process was skipped
+- As a pre-push check
+- When onboarding — validates that TLC discipline is being followed

package/.claude/commands/tlc/help.md

@@ -57,6 +57,38 @@ Launches the visual dashboard. Detects where you are, shows what's next.
 | `/tlc:release` | Release a claimed task |
 | `/tlc:who` | Show who's working on what |
 
+### Plugins (auto-run via hooks)
+
+**After `/tlc:build`** (code written):
+guard → preflight → review (Claude + Codex) → if APPROVED → push + PR
+
+**After `git push`** (CI triggered):
+watchci (monitor GH Actions) → if green → e2e-verify (screenshots + logs)
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:guard` | Validates TLC process: plan quality, test-first compliance, coverage thresholds |
+| `/tlc:preflight` | Completeness check — all references, registries, configs, distribution paths |
+| `/tlc:review` | Multi-LLM review gate — Claude + Codex must both APPROVE before push |
+| `/tlc:watchci` | After push: monitors GH Actions, reads failure logs, fixes until green |
+| `/tlc:e2e-verify` | After CI green: Playwright screenshots, visual inspection, log checking |
+
+These fire automatically via PostToolUse hooks. You can also invoke them manually.
+
+### Code Quality
+
+| Command | What It Does |
+|---------|--------------|
+| `/tlc:review` | Review current branch |
+| `/tlc:review-pr` | Review a pull request |
+| `/tlc:refactor` | Step-by-step standards refactoring |
+| `/tlc:cleanup` | Automatic standards cleanup |
+| `/tlc:audit` | Check coding standards compliance |
+| `/tlc:security` | Security audit |
+| `/tlc:outdated` | Check outdated dependencies |
+| `/tlc:edge-cases` | Generate edge case tests |
+| `/tlc:quality` | Test quality scoring |
+
 ### Enterprise (v1.4+)
 
 | Command | What It Does |

package/.claude/commands/tlc/init.md

@@ -262,9 +262,21 @@ All implementation follows **Red → Green → Refactor**:
 3. **Refactor**: Clean up while keeping tests green
 ```
 
-### 9b. Create Claude Settings for Bash Permissions (Automatic)
+### 9b. Create Claude Settings with Permissions AND Hooks (Automatic)
 
-**Always create `.claude/settings.json` during init.** This is not optional — TLC requires these permissions to run tests, commit, and build without interruption.
+**Always create `.claude/settings.json` during init.** This is not optional — TLC requires permissions for uninterrupted work AND hooks for the plugin system (enforcement, auto-verification, memory capture).
+
+**Also create `.claude/hooks/` directory** and copy all hook scripts from the TLC package. The hooks power the plugin system — without them, TLC is commands-only with no automation.
+
+Create `.claude/hooks/` with these scripts (copy from the installed TLC package at `~/.claude/hooks/` or from the npm package):
+- `tlc-block-tools.sh` — Blocks non-TLC planning tools (EnterPlanMode, TaskCreate, etc.)
+- `tlc-prompt-guard.sh` — Smart intent detection: parses user message for plan/build/fix/deploy intent and routes to the correct TLC command
+- `tlc-session-init.sh` — Initializes TLC state and ensures server is running
+- `tlc-post-push.sh` — Auto-triggers CI monitoring after `git push`
+- `tlc-post-build.sh` — Auto-triggers guard + e2e verification after build/plan
+- `tlc-capture-exchange.sh` — Captures conversations to team memory
+
+Make all hook scripts executable: `chmod +x .claude/hooks/*.sh`
 
 Create `.claude/settings.json`:
 
@@ -272,46 +284,70 @@ Create `.claude/settings.json`:
 {
   "permissions": {
     "allow": [
-      "Bash(npm *)",
-      "Bash(npx *)",
-      "Bash(node *)",
-      "Bash(git *)",
-      "Bash(gh *)",
-      "Bash(ssh *)",
-      "Bash(scp *)",
-      "Bash(rsync *)",
-      "Bash(curl *)",
-      "Bash(wget *)",
-      "Bash(docker *)",
-      "Bash(docker-compose *)",
-      "Bash(pytest*)",
-      "Bash(python *)",
-      "Bash(pip *)",
-      "Bash(go *)",
-      "Bash(cargo *)",
-      "Bash(make *)",
-      "Bash(cat *)",
-      "Bash(ls *)",
-      "Bash(pwd*)",
-      "Bash(cd *)",
-      "Bash(mkdir *)",
-      "Bash(cp *)",
-      "Bash(mv *)",
-      "Bash(which *)",
-      "Bash(echo *)",
-      "Bash(jq *)",
-      "Bash(wc *)",
-      "Bash(head *)",
-      "Bash(tail *)",
-      "Bash(sort *)",
-      "Bash(uniq *)",
-      "Bash(xargs *)"
+      "Bash(npm *)", "Bash(npx *)", "Bash(node *)", "Bash(git *)",
+      "Bash(gh *)", "Bash(ssh *)", "Bash(scp *)", "Bash(rsync *)",
+      "Bash(curl *)", "Bash(wget *)", "Bash(docker *)", "Bash(docker-compose *)",
+      "Bash(pytest*)", "Bash(python *)", "Bash(pip *)", "Bash(go *)",
+      "Bash(cargo *)", "Bash(make *)", "Bash(cat *)", "Bash(ls *)",
+      "Bash(pwd*)", "Bash(cd *)", "Bash(mkdir *)", "Bash(cp *)",
+      "Bash(mv *)", "Bash(which *)", "Bash(echo *)", "Bash(jq *)",
+      "Bash(wc *)", "Bash(head *)", "Bash(tail *)", "Bash(sort *)",
+      "Bash(uniq *)", "Bash(xargs *)"
     ]
+  },
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "EnterPlanMode|TaskCreate|TaskUpdate|TaskList|TaskGet|ExitPlanMode",
+      "hooks": [{
+        "type": "command",
+        "command": "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-block-tools.sh",
+        "timeout": 5
+      }]
+    }],
+    "UserPromptSubmit": [{
+      "hooks": [{
+        "type": "command",
+        "command": "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-prompt-guard.sh",
+        "timeout": 5
+      }]
+    }],
+    "SessionStart": [{
+      "hooks": [{
+        "type": "command",
+        "command": "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-session-init.sh",
+        "timeout": 5
+      }]
+    }],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [{
+          "type": "command",
+          "command": "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-post-push.sh",
+          "timeout": 5
+        }]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [{
+          "type": "command",
+          "command": "bash $CLAUDE_PROJECT_DIR/.claude/hooks/tlc-post-build.sh",
+          "timeout": 5
+        }]
+      }
+    ],
+    "Stop": [{
+      "hooks": [{
+        "type": "command",
+        "command": "bash \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/tlc-capture-exchange.sh",
+        "timeout": 30
+      }]
+    }]
   }
 }
 ```
 
-If `.claude/settings.json` already exists, merge the permissions (don't overwrite user's existing config).
+If `.claude/settings.json` already exists, merge: preserve existing permissions (union), add hooks section if missing (don't overwrite existing hooks).
 
 ### 10. Create or Update PROJECT.md
 

package/.claude/commands/tlc/llm.md

@@ -28,20 +28,35 @@ Interactive setup to configure providers in `.tlc.json`:
 
 ### /tlc:llm status
 
-Show current configuration:
+Read from **`.tlc/.router-state.json`** (persistent state) and `.tlc.json` (config):
 
 ```
+LLM Router Status
+══════════════════════════════════════════════
+
+State: .tlc/.router-state.json
+  Probed: 2026-03-20T02:15:00Z (12 min ago)
+  TTL: 3600s (fresh)
+
 Providers:
   claude   ✓ /usr/local/bin/claude    [review, code-gen, refactor]
   codex    ✓ /usr/local/bin/codex     [review, code-gen]
   gemini   ✗ not found                [design, vision]
 
 Capabilities:
-  review    → claude, codex (fallback: claude)
-  code-gen  → claude
-  vision    → gemini (unavailable)
+  review    → claude, codex (fallback: claude)     2/2 available
+  code-gen  → claude                               1/1 available
+  vision    → gemini (unavailable)                  0/1 available
+
+Pipeline Integration:
+  Post-build review: claude + codex (consensus required)
+  Post-push e2e: claude (in-session)
 ```
 
+The state file is written by the `SessionStart` hook and re-probed every hour. All skills read from this file — no ad-hoc `which` calls.
+
+**Force re-probe:** `/tlc:llm probe` (deletes state file, next skill invocation re-probes)
+
 ### /tlc:llm models
 
 List models available from each provider.

package/.claude/commands/tlc/preflight.md

@@ -0,0 +1,134 @@
+# /tlc:preflight - Completeness Check Before Done
+
+Never declare a task complete without running this. Catches gaps, loose ends, and half-solutions before they ship.
+
+## Philosophy
+
+**Assume nothing is complete.** Every task has edges you didn't think about. This skill forces you to actively look for what's missing rather than confirming what's present.
+
+## When This Runs
+
+This is a **plugin** — it fires automatically via PostToolUse hook whenever Claude is about to declare work "done." You don't invoke it manually.
+
+It also runs:
+- After `/tlc:build` (via guard + preflight chain)
+- After any multi-file change
+- Before recommending a commit or push
+
+## Process
+
+### Step 1: Inventory What Was Changed
+
+List every file that was created, modified, or deleted in this session. For each one:
+- What was the intent?
+- Was the change completed or left partial?
+
+### Step 2: Trace All References
+
+For every file changed, check:
+- **Is it registered/imported where needed?** (e.g., new module added to an index, new command added to a commands array, new route added to a router)
+- **Does anything else reference it?** (e.g., config files, package.json, install scripts, documentation)
+- **Are there parallel systems that need the same update?** (e.g., install.js AND postinstall.js, package.json `files` AND `bin`, CLAUDE.md AND help.md)
+
+This is the #1 source of half-solutions: changing the thing but not updating everything that points to the thing.
+
+### Step 3: Check Consistency Across Layers
+
+For each change, verify consistency across ALL layers:
+
+| Layer | Check |
+|-------|-------|
+| **Source files** | Does the code do what was intended? |
+| **Tests** | Do tests exist and pass? |
+| **Config** | Are config files updated (package.json, .tlc.json, settings.json)? |
+| **Distribution** | Will this ship to end users? (files array, install scripts, postinstall) |
+| **Documentation** | Is the change reflected in docs, help text, command tables? |
+| **Integration** | Do other systems that depend on this still work? |
+
+### Step 4: Ask the Hard Questions
+
+Before declaring done, explicitly answer each:
+
+1. **"If someone installs this fresh right now, will it work?"**
+   - Not "does it work on my machine" — does it work from a clean install?
+
+2. **"What did I assume exists that might not?"**
+   - Files, directories, env vars, running services, permissions
+
+3. **"What's the blast radius?"**
+   - What else touches the same files/systems I changed?
+   - Did I update ALL of those touchpoints?
+
+4. **"Is there a parallel path I forgot?"**
+   - Two install scripts? Two config files? Multiple places the same list appears?
+
+5. **"What would a user try that I didn't test?"**
+   - Edge cases in usage, not just happy path
+
+### Step 5: Report
+
+**If gaps found:**
+```
+PREFLIGHT CHECK — GAPS FOUND
+
+Changes made: 3 files created, 2 files modified
+
+Gaps:
+1. Created new-feature.md but not added to COMMANDS array in install.js
+2. Modified settings.json but init.md template not updated to match
+3. No test file for new utility function
+
+Fix these before declaring done.
+```
+
+**If clean:**
+```
+PREFLIGHT CHECK — CLEAR
+
+Changes made: 3 files created, 2 files modified
+All references updated: ✅
+Distribution verified: ✅
+Tests exist: ✅
+Config consistent: ✅
+
+Task is complete.
+```
+
+## Common Gap Patterns
+
+These are the most frequent gaps this skill catches:
+
+| Pattern | Example |
+|---------|---------|
+| **Registry miss** | New file created but not added to install array, export list, or index |
+| **Parallel system miss** | Updated install.js but not postinstall.js |
+| **Config drift** | Changed settings.json but init.md still generates the old version |
+| **Distribution miss** | File exists in repo but won't ship (not in package.json files) |
+| **Doc drift** | New command added but not in CLAUDE.md dispatch table or help.md |
+| **Test miss** | New code without corresponding test |
+| **Cross-reference miss** | Renamed something but didn't grep for all references |
+
+## Example
+
+```
+PREFLIGHT CHECK — GAPS FOUND
+
+Session changes:
+  + .claude/commands/tlc/watchci.md (new skill)
+  + .claude/commands/tlc/e2e-verify.md (new skill)
+  + .claude/commands/tlc/guard.md (new skill)
+  + .claude/hooks/tlc-post-push.sh (new hook)
+  + .claude/hooks/tlc-post-build.sh (new hook)
+  ~ .claude/settings.json (added PostToolUse hooks)
+  ~ CLAUDE.md (added dispatch entries)
+
+Gaps:
+  ❌ watchci.md, e2e-verify.md, guard.md not in COMMANDS array (bin/install.js)
+  ❌ .claude/hooks/ not in package.json files array — won't ship
+  ❌ postinstall.js doesn't copy hooks — fresh install broken
+  ❌ init.md settings template doesn't include new hooks
+  ❌ help.md doesn't list new commands
+  ❌ bootstrap.md was already missing from COMMANDS array (pre-existing gap)
+
+6 gaps found. Fix before declaring done.
+```

package/.claude/commands/tlc/recall.md

@@ -0,0 +1,87 @@
+# /tlc:recall - Semantic Memory Search
+
+Search your project's memory by meaning. "What did we decide about X?"
+
+## Usage
+
+```
+/tlc:recall <query>
+```
+
+## What This Does
+
+1. Searches the vector memory store using semantic similarity
+2. Ranks results by: similarity (50%) + recency (25%) + project relevance (25%)
+3. Returns top-5 results with scores, types, and excerpts
+4. Permanent memories get a 1.2x boost in scoring
+
+## Options
+
+```
+/tlc:recall database architecture
+/tlc:recall --scope workspace authentication approach
+/tlc:recall --type decision deployment strategy
+/tlc:recall --limit 10 API design
+```
+
+| Flag | Values | Default | Description |
+|------|--------|---------|-------------|
+| `--scope` | `project`, `workspace`, `global` | `project` | Search scope (auto-widens if few results) |
+| `--type` | `decision`, `gotcha`, `conversation`, `all` | `all` | Filter by memory type |
+| `--limit` | 1-20 | 5 | Maximum results |
+
+## Process
+
+### Step 1: Parse Query
+
+Extract the search query and any flags from the arguments.
+
+### Step 2: Semantic Search
+
+1. Generate embedding for the query
+2. Search vector store for nearest neighbors
+3. Score results: `similarity * 0.5 + recency * 0.25 + projectRelevance * 0.25`
+4. Boost permanent memories by 1.2x
+5. Apply scope, type, and limit filters
+
+### Step 3: Display Results
+
+```
+## Memory Recall: "database architecture"
+
+1. **Use SQLite for vector storage** (92% match) [decision]
+   Date: 2026-02-09
+   Zero infrastructure, single file, ships with TLC
+   Source: memory/decisions/2026-02-09-use-sqlite-for-vector-storage.md
+
+2. **[PERMANENT] Always use WAL mode** (87% match) [gotcha]
+   Date: 2026-02-08
+   WAL mode required for concurrent reads during indexing
+   Source: memory/gotchas/2026-02-08-always-use-wal-mode.md
+
+3. **Database migration strategy** (81% match) [conversation]
+   Date: 2026-02-07
+   Discussed migration approach, decided on schema-first
+   Source: memory/conversations/2026-02-07-database-migration.md
+```
+
+### Step 4: Fallback
+
+If the vector store is unavailable (Ollama not running, no embeddings):
+- Falls back to keyword-based text search
+- Shows a notice that semantic search is unavailable
+
+## Examples
+
+```
+/tlc:recall what database should we use
+/tlc:recall deployment strategy --scope global
+/tlc:recall --type decision authentication
+/tlc:recall testing approach --limit 10
+```
+
+## Graceful Degradation
+
+- **No Ollama**: Falls back to text search with keyword matching
+- **Empty store**: Shows "No memories indexed yet" with guidance to run `/tlc:remember`
+- **No results**: Shows "No matching memories" with search suggestions

package/.claude/commands/tlc/remember.md

@@ -0,0 +1,71 @@
+# /tlc:remember - Permanent Memory Capture
+
+Save important context permanently so it survives context compaction.
+
+## Usage
+
+```
+/tlc:remember <text>
+```
+
+Or without arguments to capture recent exchanges:
+```
+/tlc:remember
+```
+
+## What This Does
+
+1. Captures the provided text (or recent conversation) as a **permanent memory**
+2. Writes it to `memory/conversations/` with `[PERMANENT]` prefix and `permanent: true` frontmatter
+3. Indexes it in the vector store for semantic recall
+4. Permanent memories are **never pruned** and get a **1.2x boost** in recall scoring
+
+## Process
+
+### Step 1: Determine What to Remember
+
+**With text argument:**
+- Use the provided text as the memory content
+
+**Without arguments:**
+- Capture the recent conversation exchanges from the current session
+- Generate a summary from the exchanges
+
+### Step 2: Write Permanent Memory
+
+1. Create a conversation chunk with `permanent: true`
+2. Title prefixed with `[PERMANENT]`
+3. Write to `memory/conversations/YYYY-MM-DD-{slug}.md`
+4. YAML frontmatter includes `permanent: true`
+
+### Step 3: Index in Vector Store
+
+1. Generate embedding for the memory content
+2. Store in vector database with `permanent = 1` flag
+3. This memory will be boosted 1.2x in future recall searches
+
+### Step 4: Confirm
+
+```
+Remembered permanently: {summary}
+File: memory/conversations/2026-02-09-always-use-utc.md
+```
+
+## Examples
+
+```
+/tlc:remember Always use UTC timestamps in the database, never local time
+
+/tlc:remember The API rate limit is 100 requests per minute per user
+
+/tlc:remember
+(captures recent conversation context)
+```
+
+## When to Use
+
+- **Architecture decisions** that should never be forgotten
+- **Environment gotchas** that are hard to rediscover
+- **Team conventions** that must be consistent
+- **Critical constraints** from stakeholders
+- Any knowledge you want to survive across sessions and context compaction