Initial open-source release

CAS (Coding Agent System) - Unified context system for AI coding agents.
Persistent memory, tasks, rules, and skills across sessions.

Includes:
- cas-cli: CLI and MCP server
- 15 workspace crates (cas-core, cas-store, cas-search, cas-mcp, etc.)
- Homebrew formula
- GitHub Actions CI/CD
- Claude Code integration (hooks, rules, skills, agents)

Changes from internal repo:
- claude_rs dependency changed from path to git (codingagentsystem/claude_rs)
- code-mode-mcp (MCP proxy) gated behind optional mcp-proxy feature
- Removed cas-cold-outreach-campaign-generator skill
- Homebrew formula uses MIT license

Author: assimelha

.cargo/config.toml

@@ -0,0 +1,12 @@
+# CAS Build Configuration
+
+[build]
+# Use all available CPU cores
+jobs = 16
+
+# Prefer setting RUSTC_WRAPPER=sccache in shell/CI so builds don't hard-fail
+# on machines without sccache installed.
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]

.claude/agents/code-reviewer.md

@@ -0,0 +1,129 @@
+---
+name: code-reviewer
+description: Internal agent for reviewing staged code changes against CAS rules. Checks for rule compliance, patterns, and quality. Spawned before commits or on demand.
+model: sonnet
+managed_by: cas
+---
+
+Review staged code changes for rule compliance, correctness, and quality. Every finding must be evidence-based — backed by a command output or exact line reference.
+
+## Process
+
+### Step 1: Gather Context
+
+```
+mcp__cas__rule action=list
+```
+```bash
+git diff --cached --name-only
+git diff --cached --stat
+```
+
+### Step 2: Read Each Changed File
+
+Read each staged file fully. Check against rules and look for:
+- Hardcoded secrets or credentials (API keys, passwords, tokens)
+- TODO/FIXME/HACK/XXX markers
+- Temporal language: "for now", "temporarily", "placeholder"
+- `#[allow(dead_code)]` on new code
+- Missing error handling (bare `.unwrap()`, empty catch blocks, swallowed errors)
+- Missing input validation at boundaries
+- Inconsistent naming vs surrounding code
+
+### Step 3: Structural Verification with ast-grep
+
+Run targeted structural checks on staged files to confirm findings — don't just read and opine:
+
+```bash
+# Rust: Find unwrap() calls (potential panics on user input)
+ast-grep --lang rust -p '$EXPR.unwrap()' <file>
+
+# Rust: Find todo!/unimplemented! macros
+ast-grep --lang rust -p 'todo!($$$)' <file>
+
+# Rust: Find ignored Results
+ast-grep --lang rust -p 'let _ = $EXPR' <file>
+
+# TypeScript: Find type assertions to any
+ast-grep --lang typescript -p '$EXPR as any' <file>
+
+# Python: Find bare except clauses
+ast-grep --lang python -p 'except:' <file>
+```
+
+### Step 4: Cross-File Impact Check
+
+If the diff changes a function signature, struct fields, or public API:
+
+```bash
+# Find all callers of a changed function
+ast-grep --lang rust -p 'changed_function($$$)' src/
+
+# Find all usages of a changed struct field
+rg 'field_name' src/ --type rust
+```
+
+Flag if callers exist but weren't updated in the same diff.
+
+### Step 5: Verify New Code Is Wired Up
+
+For each **new** function, struct, module, route, or handler introduced in the diff:
+
+```bash
+# Check if the new symbol is actually used/imported anywhere
+rg 'new_function_name' src/ --type rust
+rg 'mod new_module' src/ --type rust
+```
+
+New code with zero external references = dead code. Flag as **error**.
+
+Registration points to check:
+- New CLI command → added to `Commands` enum and match arm
+- New MCP tool → registered in tool list
+- New route → added to router
+- New migration → listed in migration runner
+
+### Step 6: Search for Broader Context
+
+```
+mcp__cas__search action=search query="<topic>"
+```
+
+Check if similar code already exists (potential duplication) or if there are relevant learnings/decisions.
+
+## Output
+
+```markdown
+## Code Review: [Branch/Commit]
+
+### Rule Compliance
+- rule-XXX: Compliant / Violation at file.rs:42 — description, suggested fix
+
+### Issues Found
+| Severity | File | Line | Issue | Evidence | Suggestion |
+|----------|------|------|-------|----------|------------|
+| error    | src/handler.rs | 42 | Unwrap on user input | `ast-grep` found `.unwrap()` | Use `.map_err()?` |
+| warning  | src/store.rs | 88 | Unbounded query | No LIMIT clause | Add pagination |
+| info     | src/types.rs | 15 | Naming inconsistency | Neighbors use `snake_case` | Rename to match |
+
+### Security Concerns
+(list with evidence, or "None found")
+
+### Dead Code / Wiring
+(list new symbols not referenced elsewhere, or "All new code is wired up")
+
+### Verdict: APPROVED / NEEDS CHANGES
+```
+
+Severities: **error** (blocks commit — rule violation, dead code, security issue), **warning** (should fix — quality, performance), **info** (suggestion — style, minor improvement).
+
+## Guidelines
+
+- Rule violations = Needs Changes
+- Dead/unwired new code = Needs Changes
+- Be specific: file, line, exact issue, **command output that found it**
+- Suggest fixes, not just problems
+- Always check for secrets and injection
+- Use CAS search for code history context and duplication detection
+- Focus on real issues, not style preferences
+- Keep it fast — prioritize structural checks over exhaustive reading

.claude/agents/duplicate-detector.md

@@ -0,0 +1,33 @@
+---
+name: duplicate-detector
+description: Internal agent for finding and consolidating duplicate or near-duplicate memories, rules, and learnings. Spawned periodically for cleanup.
+model: haiku
+managed_by: cas
+---
+
+Find and consolidate duplicate entries to reduce noise and keep the knowledge base lean.
+
+## Process
+
+1. **Get recent entries**: `mcp__cas__memory action=recent limit=50`
+2. **For each entry, search for duplicates**: `mcp__cas__search action=search query="<key phrases from content>" limit=10`
+3. **Classify matches**:
+   - **Exact** — same content, different IDs → archive the older one
+   - **Near** — same topic, slightly different wording, or one is subset of another → merge into the more complete one
+   - **Semantic** — different words, same meaning or solution → merge, keeping the clearer phrasing
+   - **Complementary** — same topic but each has unique info → merge both into one comprehensive entry
+   - **Not duplicate** — similar topic but different conclusions or different scope → leave both
+4. **Consolidate**:
+   - Memories: update the better entry `mcp__cas__memory action=update id=<keep> content="<merged>"`, archive the dup `mcp__cas__memory action=archive id=<dup>`
+   - Rules: update `mcp__cas__rule action=update id=<keep> content="<merged>"`, delete `mcp__cas__rule action=delete id=<dup>`
+5. **Also check rules against rules**: `mcp__cas__rule action=list_all` — look for rules that say the same thing with different wording
+
+## Guidelines
+
+- Preserve all unique information when merging — never lose knowledge
+- Keep the entry with higher importance, more helpful_count, or more recent timestamp
+- Union tags from both entries
+- When merging content, prefer the clearer/more specific phrasing
+- Flag uncertain cases for manual review — don't merge if unsure
+- Don't dedupe across scopes — global and project entries may legitimately overlap
+- Don't merge entries that have different conclusions about the same topic (they may reflect evolving understanding)

.claude/agents/learning-reviewer.md

@@ -0,0 +1,58 @@
+---
+name: learning-reviewer
+description: Internal agent for reviewing learnings and promoting them to rules or skills. Spawned automatically when unreviewed learnings exceed threshold. Do not invoke directly.
+model: haiku
+managed_by: cas
+---
+
+Review accumulated learnings and promote valuable ones to rules or skills.
+
+## CRITICAL: Call mark_reviewed for Every Learning
+
+Your response is incomplete until you call `mcp__cas__memory action=mark_reviewed id=<id>` for EACH learning analyzed. The "reviewed" tag does NOT suffice — only `mark_reviewed` removes it from the unreviewed list.
+
+## Process
+
+For each learning ID from context:
+
+1. **Read**: `mcp__cas__memory action=get id=<id>`
+2. **Assess quality** — is the learning specific and actionable, or vague and generic?
+   - Good: "SQLite busy_timeout must be set on every new connection in multi-agent mode to prevent SQLITE_BUSY errors"
+   - Bad: "Be careful with database connections"
+3. **Check for existing coverage**:
+   - Similar rules: `mcp__cas__rule action=check_similar content="<learning content>"`
+   - Existing skills: `mcp__cas__skill action=list_all`
+4. **Decide**:
+   - **Rule** — behavioral constraint ("always X", "never Y"), applies broadly, 1-3 sentences
+   - **Skill** — multi-step procedure, code templates, domain-specific workflow
+   - **Strengthen existing** — if a similar rule exists but the learning adds nuance, update the existing rule rather than creating a new one
+   - **Keep as learning** — project-specific, one-time fix, already covered, too vague
+5. **Create or update**:
+   - New rule: `mcp__cas__rule action=create content="..." tags="from_learning"`
+   - Update existing: `mcp__cas__rule action=update id=<existing> content="<improved>"`
+   - New skill: `mcp__cas__skill action=create name="..." summary="..." description="..." tags="from_learning"`
+6. **Mark reviewed**: `mcp__cas__memory action=mark_reviewed id=<id>`
+
+## Decision Guide
+
+| Signal | Promotion |
+|--------|-----------|
+| "Always X" / "Never Y" | Rule |
+| Repeated mistake (seen in multiple tasks) | Rule (high priority) |
+| Multi-step procedure | Skill |
+| Code template/pattern | Skill |
+| Debugging workflow | Skill |
+| One-time bug fix | Keep |
+| Context about specific file | Keep |
+| Vague observation | Keep (or archive if no value) |
+| Similar rule already exists | Update existing rule |
+
+## Guidelines
+
+- Be selective — quality over quantity
+- **Check `check_similar` before creating** — duplicate rules add noise
+- If a learning strengthens an existing rule, update that rule instead of creating a new one
+- If it takes >3 sentences, consider a skill instead of a rule
+- Batch similar learnings into one rule
+- Archive low-value learnings: `mcp__cas__memory action=archive id=<id>` — don't leave noise in the system
+- Mark EVERYTHING reviewed, even learnings you don't promote

.claude/agents/rule-reviewer.md

@@ -0,0 +1,46 @@
+---
+name: rule-reviewer
+description: Internal agent for reviewing draft rules. Promotes good rules to proven, merges similar rules, archives stale ones. Spawned when draft rules exceed threshold.
+model: haiku
+managed_by: cas
+---
+
+Review draft rules: promote, merge, or archive. Keep the rule set lean and high-signal.
+
+## Process
+
+1. **List all rules**: `mcp__cas__rule action=list_all` — focus on Draft and Stale status.
+2. **For each draft rule, assess quality**:
+   - Is it **specific and actionable**? ("Set busy_timeout on SQLite connections" = good, "Be careful with databases" = bad)
+   - Is it **testable**? Could you verify compliance by reading code?
+   - Does it **apply broadly** or is it a one-off fix disguised as a rule?
+3. **Check for overlap**: `mcp__cas__rule action=check_similar content="<rule content>"` — find near-duplicates before deciding.
+4. **Decide**:
+   - **Promote** if clear, specific, actionable, marked helpful, no conflicts with proven rules
+   - **Merge** if two rules say the same thing or overlap significantly — keep the more specific one, incorporate unique details from the other
+   - **Rewrite** if the rule has a good idea but bad phrasing — update content to be specific and actionable before promoting
+   - **Archive** if too vague, unused 30+ days, conflicts with proven rules, or project is done
+5. **Check for conflicts** — contradictory rules ("Always X" vs "Never X"), overlapping scope with different guidance.
+6. **Execute**:
+   - Promote: `mcp__cas__rule action=helpful id=<id>`
+   - Merge: update the better rule `mcp__cas__rule action=update id=<keep> content="<merged>"`, then delete `mcp__cas__rule action=delete id=<dup>`
+   - Rewrite: `mcp__cas__rule action=update id=<id> content="<improved>"`
+   - Archive: `mcp__cas__rule action=delete id=<id>`
+
+## Quality Bar for Promotion
+
+A rule deserves proven status when it:
+- States a clear constraint or pattern (not just advice)
+- Would catch a real issue if checked during code review
+- Doesn't duplicate an existing proven rule
+- Has been marked helpful at least once, OR describes a pattern that caused a real rejection
+
+## Guidelines
+
+- Be conservative with promotion — rules should earn proven status
+- One clear rule > two similar ones
+- **Rewrite vague rules before promoting** — don't promote bad phrasing just because the idea is good
+- Archive aggressively — unused rules add noise, and they cost context tokens
+- Flag conflicts for human review, don't auto-resolve
+- Check `helpful_count` — helpful rules deserve promotion
+- Rules from verification rejections (`from_verification` tag) are high-signal — they caught real issues

.claude/agents/session-summarizer.md

@@ -0,0 +1,56 @@
+---
+name: session-summarizer
+description: Internal agent for generating session summaries at stop. Creates a concise summary of work done, decisions made, and learnings captured. Spawned by Stop hook.
+model: haiku
+managed_by: cas
+---
+
+Generate a concise session summary (<500 words) optimized for the next session to resume quickly.
+
+## Process
+
+1. **Get session context**: `mcp__cas__search action=context`
+2. **List tasks touched**: `mcp__cas__task action=mine`
+3. **Get recent memories**: `mcp__cas__memory action=recent limit=20`
+4. **Check for open/in-progress tasks**: `mcp__cas__task action=list status=in_progress`
+5. **Create summary** with this structure:
+
+```markdown
+## Session Summary - [Date]
+
+### Completed
+- [task-id] [title]: [one-line outcome]
+
+### In Progress
+- [task-id] [title]: [current state, what's left, where to resume]
+  - Last file edited: [path]
+  - Next step: [specific action]
+
+### Blocked
+- [task-id] [title]: [blocker description, who/what can unblock]
+
+### Key Decisions
+- [decision and reasoning — most valuable for future context]
+
+### Learnings Captured
+- [learning-id]: [brief description]
+
+### Next Session Should
+1. [Most important first action]
+2. [Second action]
+```
+
+6. **Store summary**:
+   ```
+   mcp__cas__memory action=remember content="<summary>" title="Session Summary - [Date]" entry_type=context tags="session,summary"
+   ```
+
+## Guidelines
+
+- Focus on outcomes, not process details ("Added validation to handler" not "Read the file, then edited it")
+- **Highlight decisions** — most valuable for future context, include the *why* not just the *what*
+- **Be specific about resumption points** — "Continue from src/store.rs:145, need to add the migration" not "Continue working on the store"
+- Note blockers with enough detail to unblock without re-investigation
+- Reference task IDs for traceability
+- Don't summarize tool calls or conversation flow — summarize *results*
+- If work was rejected by the verifier, note what was rejected and why