token-saver-meta 0.1.0__tar.gz

token_saver_meta-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,17 @@
+{
+  "name": "token-saver-meta",
+  "version": "0.1.0",
+  "description": "Zero-config token-saving protocol for AI coding agents — injects caveman + ponytail + LG-token-saver + kevin-copilot rules",
+  "author": {"name": "Im-Busy"},
+  "hooks": [
+    {
+      "type": "InstructionsLoaded",
+      "matchers": ["session_start", "compact"]
+    },
+    {
+      "type": "SessionStart",
+      "matchers": ["startup", "resume", "clear", "compact"]
+    }
+  ],
+  "skills": ["skills/token-saver/SKILL.md"]
+}

token_saver_meta-0.1.0/.gitattributes

@@ -0,0 +1,9 @@
+* text=auto
+*.py text eol=lf
+*.js text eol=lf
+*.md text eol=lf
+*.json text eol=lf
+*.toml text eol=lf
+*.txt text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf

token_saver_meta-0.1.0/.github/workflows/publish-npm.yml

@@ -0,0 +1,23 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+      - name: Publish to npm
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

token_saver_meta-0.1.0/.github/workflows/publish-pypi.yml

@@ -0,0 +1,33 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Install dependencies
+        run: uv sync
+      - name: Run all tests
+        run: uv run pytest tests/ tscg-py/tests/ token-saver-mem/tests/ contextslim-py/tests/ -q
+
+  build-publish:
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - name: Build package
+        run: uv build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          attestations: true

token_saver_meta-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+.pytest_cache/
+.ruff_cache/
+.venv/
+# Node
+node_modules/
+# Tool output
+CODESIGHT.md
+repomix-output.*
+.repomixignore
+.bak-*
+.codegraph/
+# Cloned reference repos (never track)
+useful-repos/
+# Sub-project coverage
+**/__pycache__/
+**/*.pyc
+**/.pytest_cache/
+**/.venv/
+**/dist/
+**/*.egg-info/

token_saver_meta-0.1.0/.kilo/agent/repo-syncer.md

@@ -0,0 +1,34 @@
+# repo-syncer Agent
+
+Safely syncs the private `master` branch to the public `public` branch for the curated public mirror.
+
+## Workflow
+
+1. **Verify remotes**: Confirm `private` and `public` remotes are configured
+2. **Checkout public**: `git checkout public`
+3. **Merge master**: `git merge master` — bring all private branch changes in
+4. **Safety check**: Verify NO private files exist on public branch after merge:
+   - `git ls-tree --name-only HEAD | grep -E "MEMORY\.md|kilo\.json|opencode\.jsonc|token-saver-meta\.md|progress_docs/|\.kilo/|\.omo/|\.codegraph/"` must return empty
+5. **Checkout master**: `git checkout master`
+6. **Push public**: `git push public public`
+
+## Private Files (must never appear on public branch)
+
+- `MEMORY.md` — Agent handover state
+- `kilo.json` — Kilo platform config
+- `opencode.jsonc` — OpenCode config
+- `token-saver-meta.md` — Brainstorm doc
+- `.kilo/` — Agent definitions
+- `.omo/` — Plan artifacts
+- `.codegraph/` — Local codegraph index
+- `progress_docs/` — Handover notes, session logs
+
+## Emergency: If private files appear on public remote
+
+```bash
+git checkout public
+git rm --cached -r <leaked-file-or-dir>
+git commit -m "emergency: remove leaked private files"
+git push public public
+```
+Then review why the safety check failed.

token_saver_meta-0.1.0/.kilo/command/repo-sync.md

@@ -0,0 +1,31 @@
+# repo-sync Command
+
+Slash command for dual-repo sync management.
+
+## Usage
+
+### Full Sync
+```
+/repo-sync
+```
+Invokes the `repo-syncer` agent: merge `master` → `public` → safety check → push.
+
+### Safety Check Only
+```
+/repo-sync check
+```
+Runs the safety verification without pushing: checks `public` branch for any private files.
+
+### Status
+```
+/repo-sync status
+```
+Shows current branch, remote configuration, and last sync state.
+
+## Examples
+
+```
+/repo-sync           # Full sync: merge + check + push
+/repo-sync check     # Verify no private files on public branch
+/repo-sync status    # Show current state
+```

token_saver_meta-0.1.0/.kilo/skills/token-saver/caveman/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: caveman
+description: >
+  Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman
+  while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra,
+  wenyan-lite, wenyan-full, wenyan-ultra.
+  Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens",
+  "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.
+---
+
+Respond terse like smart caveman. All technical substance stay. Only fluff die.
+
+## Persistence
+
+ACTIVE EVERY RESPONSE. No revert after many turns. No filler drift. Still active if unsure. Off only: "stop caveman" / "normal mode".
+
+Default: **full**. Switch: `/caveman lite|full|ultra`.
+
+## Rules
+
+Drop: articles (a/an/the), filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Fragments OK. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked — quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations reader can't decode. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Preserve user's dominant language. User write Portuguese → reply Portuguese caveman. User write Spanish → reply Spanish caveman. Compress the style, not the language. No forced English openings or status phrases. ALWAYS keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim — unless user explicitly ask for translation.
+
+No self-reference. Never name or announce the style. No "caveman mode on", "me caveman think", no third-person caveman tags. Output caveman-only — never normal answer plus "Caveman:" recap. Exception: user explicitly ask what the mode is.
+
+Pattern: `[thing] [action] [reason]. [next step].`
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use `<` not `<=`. Fix:"
+
+## Intensity
+
+| Level | What change |
+|-------|------------|
+| **lite** | No filler/hedging. Keep articles + full sentences. Professional but tight |
+| **full** | Drop articles, fragments OK, short synonyms. Classic caveman. No tool-call narration, no decorative tables/emoji, no long raw error-log dumps unless asked. Standard acronyms OK; no invented abbreviations |
+| **ultra** | Abbreviate prose words (DB/auth/config/req/res/fn/impl) — prose words only, never real code symbols/function names. Strip conjunctions, arrows for causality (X → Y), one word when one word enough. Code symbols, function names, API names, error strings: never abbreviate |
+| **wenyan-lite** | Semi-classical. Drop filler/hedging but keep grammar structure, classical register |
+| **wenyan-full** | Maximum classical terseness. Fully 文言文. 80-90% character reduction. Classical sentence patterns, verbs precede objects, subjects often omitted, classical particles (之/乃/為/其) |
+| **wenyan-ultra** | Extreme abbreviation while keeping classical Chinese feel. Maximum compression, ultra terse |
+
+Example — "Why React component re-render?"
+- lite: "Your component re-renders because you create a new object reference each render. Wrap it in `useMemo`."
+- full: "New object ref each render. Inline object prop = new ref = re-render. Wrap in `useMemo`."
+- ultra: "Inline obj prop → new ref → re-render. `useMemo`."
+- wenyan-lite: "組件頻重繪，以每繪新生對象參照故。以 useMemo 包之。"
+- wenyan-full: "每繪新生對象參照，故重繪；以 useMemo 包之則免。"
+- wenyan-ultra: "新參照→重繪。useMemo Wrap。"
+
+Example — "Explain database connection pooling."
+- lite: "Connection pooling reuses open connections instead of creating new ones per request. Avoids repeated handshake overhead."
+- full: "Pool reuse open DB connections. No new connection per request. Skip handshake overhead."
+- ultra: "Pool = reuse DB conn. Skip handshake → fast under load."
+- wenyan-full: "池reuse open connection。不每req新開。skip handshake overhead。"
+- wenyan-ultra: "池reuse conn。skip handshake → fast。"
+
+## Auto-Clarity
+
+Drop caveman when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity (e.g., `"migrate table drop column backup first"` — order unclear without articles/conjunctions)
+- User asks to clarify or repeats question
+
+Resume caveman after clear part done.
+
+Example — destructive op:
+> **Warning:** This will permanently delete all rows in the `users` table and cannot be undone.
+> ```sql
+> DROP TABLE users;
+> ```
+> Caveman resume. Verify backup exist first.
+
+## Boundaries
+
+Code/commits/PRs: write normal. "stop caveman" or "normal mode": revert. Level persist until changed or session end.

token_saver_meta-0.1.0/.kilo/skills/token-saver/kevin-copilot/SKILL.md

@@ -0,0 +1,341 @@
+---
+name: unslop
+description: "Unified de-slop pass: code simplification + comment rot detection + design slop check. Run after completing features or before PRs to strip AI-generated generic patterns."
+argument-hint: "[blank for recent changes, or file/directory path]"
+---
+
+# /unslop — Strip AI Slop from Your Codebase
+
+Three parallel analysis passes that detect and report AI-generated "slop" — generic, template-looking, over-enthusiastic output that makes code, comments, and UI feel artificial.
+
+## When to Use
+
+- After completing a feature — check for slop before PR
+- Before code review — pre-clean your changes
+- When code "feels AI-generated" but you can't pinpoint why
+- Periodic codebase hygiene — run on a directory
+- After a long AI-assisted session to audit quality
+
+## Argument Parsing
+
+Parse `$ARGUMENTS` for these tokens:
+
+| Token | Example | Effect |
+|-------|---------|--------|
+| `fix` | `/unslop fix` | Auto-apply safe fixes after reporting |
+| `<path>` | `/unslop src/components/` | Scope to specific file or directory |
+| (none) | `/unslop` | Analyze all files changed since the base branch |
+
+## Execution Flow
+
+### Stage 1: Determine Scope
+
+**If a file or directory path is provided:**
+
+Scope to that path. Use `find` or glob to list all code files under it.
+
+**If no argument (default):**
+
+Determine changed files since the base branch:
+
+```bash
+BASE=$(git merge-base HEAD origin/main 2>/dev/null || git merge-base HEAD origin/master 2>/dev/null || echo "HEAD~10")
+echo "FILES:" && git diff --name-only $BASE
+echo "DIFF:" && git diff -U5 $BASE
+```
+
+**Classify files in scope:**
+
+| File extensions | Passes to run |
+|----------------|---------------|
+| `.ts`, `.tsx`, `.js`, `.jsx`, `.py`, `.go`, `.rb`, `.rs`, `.java`, `.cs`, `.swift`, `.kt` | Code Slop + Comment Rot |
+| `.css`, `.scss`, `.less`, `.tsx`, `.jsx`, `.html`, `.vue`, `.svelte` | + Design Slop |
+| `.json`, `.yaml`, `.yml`, `.toml`, `.md` | Code Slop + Comment Rot only |
+
+If no UI/style files are in scope, skip the Design Slop pass entirely.
+
+Announce the scope:
+
+```
+De-slop scope: 14 files changed since origin/main
+Passes: Code Slop | Comment Rot | Design Slop (3 UI files detected)
+```
+
+### Stage 2: Parallel Analysis
+
+Launch three sub-agents IN PARALLEL. Each receives the file list and diff content, and returns structured findings as text.
+
+<parallel_tasks>
+
+#### Pass 1: Code Slop Detector
+
+You are a code simplification expert. Analyze the provided files for AI-generated slop patterns. Focus ONLY on slop — not correctness, security, or architecture.
+
+**What to flag:**
+
+1. **Unnecessary complexity**
+   - Deep nesting (>3 levels) that could use early returns
+   - Nested ternary operators — use if/else or switch
+   - Dense one-liners that sacrifice readability for brevity
+
+2. **Redundant abstractions**
+   - Interfaces/types used only once — inline them
+   - Wrapper functions that add no logic — call the wrapped function directly
+   - Abstract base classes with a single implementation
+   - Premature generalization ("just in case" extensibility points)
+
+3. **YAGNI violations**
+   - Features not required by current use cases
+   - Configuration options nobody uses
+   - Generic solutions for specific problems
+   - "Future-proofing" code that adds complexity now
+
+4. **Dead weight**
+   - Commented-out code blocks (>3 lines)
+   - Unused imports, variables, or functions
+   - Duplicate error checks (caller already validates)
+   - Defensive code that can never trigger (type system prevents it)
+
+5. **Over-engineering**
+   - Factory patterns for creating a single type
+   - Strategy patterns with one strategy
+   - Event systems for synchronous single-consumer flows
+   - Dependency injection where direct instantiation is clearer
+
+**Return format:**
+```json
+{
+  "pass": "code-slop",
+  "findings": [
+    {
+      "file": "src/auth.ts",
+      "line": 42,
+      "issue": "Nested ternary — use if/else for readability",
+      "severity": "medium",
+      "fix_safe": true,
+      "suggested_fix": "Replace ternary chain with if/else block"
+    }
+  ]
+}
+```
+
+#### Pass 2: Comment Rot Detector
+
+You are a technical documentation expert specializing in comment quality. Analyze the provided files for comment rot — inaccurate, redundant, or AI-generated filler comments.
+
+**What to flag:**
+
+1. **Obvious restatements**
+   - `// increment counter` above `counter++`
+   - `// return the result` above `return result`
+   - `// set the name` above `this.name = name`
+   - Comments that repeat the function/variable name in prose
+
+2. **AI-generated filler phrases** (hard bans — flag these immediately)
+   - "This function is responsible for handling..."
+   - "The following code implements..."
+   - "This is a comprehensive solution that..."
+   - "This method provides a robust and scalable..."
+   - "leverages" or "utilizes" (when "uses" works fine)
+   - "seamlessly integrates"
+   - "In today's rapidly evolving..."
+   - "game-changer", "revolutionary", "cutting-edge"
+   - "This class encapsulates the logic for..."
+   - "Ensures proper handling of..."
+
+3. **Factual inaccuracy**
+   - Documented parameters that don't match the function signature
+   - Return type descriptions that don't match the actual return
+   - Described behavior that doesn't match the code logic
+   - Edge case documentation for cases not actually handled
+
+4. **Stale comments**
+   - TODOs/FIXMEs for work that's already been done
+   - References to removed/renamed functions, classes, or files
+   - Version-specific notes for versions no longer supported
+   - "Temporary" markers on permanent code
+
+5. **Over-documentation**
+   - JSDoc/docstrings on trivial getters/setters
+   - Multi-line comments on self-explanatory one-liners
+   - Repeating type information already in the signature
+   - Section divider comments (`// ==================`)
+
+**Return format:**
+```json
+{
+  "pass": "comment-rot",
+  "findings": [
+    {
+      "file": "src/auth.ts",
+      "line": 10,
+      "issue": "\"This function handles authentication\" — restates the function name",
+      "severity": "low",
+      "fix_safe": true,
+      "suggested_fix": "Remove comment — function name is self-documenting"
+    }
+  ]
+}
+```
+
+#### Pass 3: Design Slop Detector
+
+**Only run this pass when UI/style files are in scope.**
+
+You are a design quality expert. Analyze the provided UI files for AI-generated visual slop — generic, template-looking patterns that signal "an AI made this, not a designer."
+
+**What to flag:**
+
+1. **Generic color patterns**
+   - Purple-to-blue gradients (the AI default palette)
+   - Gratuitous gradients on everything (buttons, cards, backgrounds)
+   - Safe gray-on-white with one decorative accent color
+   - Unintentional color usage (decorative, not semantic)
+
+2. **Template layouts**
+   - Default card grids with uniform spacing and no hierarchy
+   - Generic hero: centered headline + subtitle + gradient blob + CTA
+   - Dashboard-by-numbers: sidebar + cards + charts with no point of view
+   - Uniform radius, spacing, and shadows across every component
+
+3. **Missing interaction states**
+   - No hover states on interactive elements
+   - No focus states (accessibility gap)
+   - No active/pressed states
+   - No loading/empty/error states
+
+4. **Lazy defaults**
+   - Unmodified library defaults (default shadcn/Tailwind without customization)
+   - Default font stacks with no intentional pairing
+   - Glassmorphism cards that serve no UI purpose
+   - Rounded corners on elements that shouldn't be rounded (tables, code blocks)
+   - Excessive scroll-triggered animations
+
+5. **No visual hierarchy**
+   - Flat layouts with no layering, depth, or motion
+   - Uniform emphasis on everything (nothing stands out)
+   - No intentional rhythm in spacing
+
+**Return format:**
+```json
+{
+  "pass": "design-slop",
+  "findings": [
+    {
+      "file": "src/Hero.tsx",
+      "line": 22,
+      "issue": "Generic purple-to-blue gradient — replace with brand palette",
+      "severity": "medium",
+      "fix_safe": false,
+      "suggested_fix": "Define an intentional brand gradient in design tokens"
+    }
+  ]
+}
+```
+
+</parallel_tasks>
+
+### Stage 3: Merge & Deduplicate
+
+**WAIT for all Stage 2 sub-agents to complete.**
+
+1. Collect findings from all passes that ran
+2. Deduplicate: if two passes flag the same file+line (within 3 lines), keep the more specific finding and note both passes
+3. Sort by severity: High → Medium → Low
+4. Group by pass for the report
+
+### Stage 4: Present Report
+
+Format the consolidated report using pipe-delimited markdown tables:
+
+```
+De-slop Report
+==============
+Scope: [N] files changed since [base]
+Passes: Code Slop [✓|✗] | Comment Rot [✓|✗] | Design Slop [✓|skipped]
+
+## Code Slop ([N] findings)
+
+| # | File | Line | Issue | Severity |
+|---|------|------|-------|----------|
+| 1 | path | line | description | High/Medium/Low |
+
+## Comment Rot ([N] findings)
+
+| # | File | Line | Issue | Severity |
+|---|------|------|-------|----------|
+| 1 | path | line | description | High/Medium/Low |
+
+## Design Slop ([N] findings)
+
+| # | File | Line | Issue | Severity |
+|---|------|------|-------|----------|
+| 1 | path | line | description | High/Medium/Low |
+
+─────────────────────────────
+Summary: [N] findings ([H] High, [M] Medium, [L] Low)
+Potential LOC reduction: ~[N] lines
+```
+
+Omit any pass section with zero findings. If all passes return zero findings:
+
+```
+De-slop Report: Clean! No slop detected in [N] files.
+```
+
+### Stage 5: Auto-Fix (only if `fix` argument was provided)
+
+If the user invoked `/unslop fix`:
+
+1. Collect all findings where `fix_safe: true`
+2. Apply fixes in file order:
+   - **Code Slop safe fixes:** Remove commented-out code blocks, remove unused imports
+   - **Comment Rot safe fixes:** Delete obvious restatement comments, remove stale TODOs
+3. Do NOT auto-fix:
+   - Design slop (requires design judgment)
+   - Factually inaccurate comments (requires understanding intent)
+   - YAGNI violations (requires knowing the roadmap)
+   - Abstractions (requires understanding the broader architecture)
+4. Report what was fixed:
+
+```
+Auto-fix applied:
+  ✓ Removed 3 commented-out code blocks (42 lines)
+  ✓ Deleted 5 obvious-restatement comments
+  ✓ Removed 2 stale TODOs
+
+  Remaining (manual review needed): 4 findings
+```
+
+If `fix` was NOT provided but fixable findings exist, suggest it:
+
+```
+Tip: Run /unslop fix to auto-apply [N] safe fixes
+```
+
+## Severity Guide
+
+| Level | Meaning | Examples |
+|-------|---------|---------|
+| **High** | Actively misleading or creates maintenance burden | Inaccurate comment, missing hover states, large dead code block |
+| **Medium** | Noticeable slop that reduces quality | Unnecessary abstraction, AI filler phrase, generic gradient |
+| **Low** | Minor quality improvement | Restatement comment, unused import, over-documentation |
+
+Slop is never "Critical" — it's a quality concern, not a correctness or security issue.
+
+## Quality Gates
+
+Before presenting findings:
+
+1. **Every finding must be actionable.** Don't say "could be simpler" — say what to change and where.
+2. **No false positives from skimming.** Verify the abstraction isn't used elsewhere before flagging it. Verify the comment is truly redundant.
+3. **Line numbers must be accurate.** Check each cited line against file content.
+4. **Respect project conventions.** If the project uses JSDoc everywhere, don't flag JSDoc as over-documentation.
+5. **Don't flag generated code.** Skip files in `dist/`, `build/`, `node_modules/`, `.next/`, `vendor/`, or similar generated directories.
+
+## Notes
+
+- This skill is read-only by default. It reports but does not edit files unless `fix` is specified.
+- Design Slop pass is automatically skipped for backend-only projects.
+- Works on any language/framework — the slop patterns are universal.
+- Pairs well with `/ce-review` (which checks correctness) — `/unslop` checks aesthetics and quality.

token_saver_meta-0.1.0/.kilo/skills/token-saver/kevin-copilot/copilot-instructions.md

@@ -0,0 +1,88 @@
+# Project Conventions
+
+This project uses the ATV (Agentic Tool & Workflow) Starter Kit.
+
+## Available Workflows
+
+- `/ce-brainstorm` — Explore what to build through collaborative dialogue
+- `/ce-plan` — Create a structured implementation plan
+- `/ce-work` — Execute the plan with quality checks
+- `/ce-review` — Multi-agent code review
+- `/ce-compound` — Document solutions for future reference
+- `/lfg` — Full autonomous pipeline (plan → work → review)
+
+## Documentation Structure
+
+- `docs/plans/` — Implementation plans (living documents with checkboxes)
+- `docs/brainstorms/` — Brainstorm documents (what to build decisions)
+- `docs/solutions/` — Documented solutions (institutional knowledge)
+
+## gstack Skills (if installed)
+
+- `/office-hours` — YC-style forcing questions to reframe your product
+- `/plan-ceo-review` — Rethink the problem; find the 10-star product
+- `/plan-eng-review` — Lock architecture, data flow, edge cases
+- `/review` — Staff-level code review; auto-fix obvious issues
+- `/qa` — Test app in real browser, find and fix bugs (requires Bun)
+- `/ship` — Sync main, run tests, push, open PR
+- `/cso` — OWASP Top 10 + STRIDE threat model
+- `/careful` — Warn before destructive commands
+- `/investigate` — Systematic root-cause debugging
+- `/retro` — Weekly retrospective with trends
+
+## Browser Automation (if installed)
+
+- `agent-browser` — Vercel's headless browser CLI for AI agents (Rust native, fast)
+- Core workflow: `agent-browser open <url>` → `snapshot -i` → interact with `@refs` → re-snapshot
+- Install: `npm install -g agent-browser && agent-browser install`
+- Use for QA testing, form filling, screenshots, data extraction, and web automation
+
+## ATV Override Rules
+
+When both ATV and gstack provide similar functionality, ATV takes priority:
+
+- **Design docs**: Write to `docs/brainstorms/` (ATV), not `DESIGN.md` (gstack)
+- **Solutions**: Document via `/ce-compound` into `docs/solutions/` (ATV), not gstack's `/retro`
+- **Plans**: Use `docs/plans/` with ATV naming (`YYYY-MM-DD-NNN-type-name-plan.md`)
+- **Reviews**: ATV's `/ce-review` agent selection governs; gstack's `/review` runs alongside
+- **Protected artifacts**: Never flag `docs/plans/`, `docs/solutions/`, `docs/brainstorms/`, `compound-engineering.local.md`, or `.github/skills/gstack/` for deletion
+
+## Coding Conventions
+
+- Follow existing patterns in the codebase
+- Write tests for new functionality
+- Use conventional commit messages (`feat:`, `fix:`, `refactor:`)
+
+## Continuous Learning Pipeline
+
+This project uses ATV's continuous learning system to capture and evolve patterns.
+
+### Learning Commands
+
+- `/learn` — Extract patterns from recent work into instincts
+- `/instincts` — View all learned patterns with confidence scores
+- `/evolve` — Promote mature instincts (confidence > 0.8) into full skills
+- `/observe` — Run a focused observation session on a specific domain
+- `/unslop` — Unified de-slop pass: strip AI-generated code slop, comment rot, and design slop
+
+### How It Works
+
+1. **Observer hooks** automatically capture tool use data to `.atv/observations.jsonl`
+2. **`/learn`** analyzes recent work and creates instincts in `.atv/instincts/project.yaml`
+3. **Instincts** build confidence over time through repeated observation
+4. **`/evolve`** promotes mature instincts into discoverable skills in `.github/skills/learned-*/`
+
+### Key Files
+
+- `.atv/observations.jsonl` — Raw tool use log (gitignored, ephemeral)
+- `.atv/instincts/project.yaml` — Learned patterns (committed, shared with team)
+- `.github/hooks/copilot-hooks.json` — Observer hook configuration
+- `.github/skills/learned-*/` — Auto-generated skills from evolved instincts
+
+### Best Practices
+
+- Run `/learn` after completing features or at session end
+- Run `/instincts` to check what patterns the project has learned
+- Run `/evolve` periodically to graduate well-established conventions
+- Run `/unslop` before PRs to strip AI-generated slop from code, comments, and UI
+- Review generated skills before committing — they're a starting point