What OmniClaude Actually Does
8 capabilities. Each one solves a problem no other tool has solved.
Artifact Registry
THE PROBLEM
Claude Code says 'saved.' The file isn't actually on disk. There's no verification that Claude's output actually persisted. You find out when you restart VS Code.
WHAT WE SOLVED
- ✓Every file Claude writes is intercepted and verified on disk
- ✓Every plan, todo, spec, and artifact is registered with:
- ✓ • File path and timestamp
- ✓ • Producing session and developer
- ✓ • SHA-256 hash for content verification
- ✓Findable across sessions — search for 'that plan I made last week'
- ✓Survives reboots, VS Code restarts, and team turnover
- ✓Status: PRODUCTION READY. 1,138 tests passing.
IMPACT
Zero lost work. Every artifact is findable. Closes the gap between 'Claude said' and 'actually exists.'
TECHNICAL IMPLEMENTATION
File write interception via PreToolUse hook. Content-addressable storage. Timestamp-based retrieval queries.
File Write Verification
THE PROBLEM
Claude says 'preserved,' 'saved,' 'done.' These words don't mean the bytes are on disk. VS Code restarts. The work is gone.
WHAT WE SOLVED
- ✓Every file write tool call is intercepted via PreToolUse hook
- ✓File checked for: existence, non-zero size, recent modification (within 5 seconds)
- ✓Verification failures trigger immediate warnings (not silent failures)
- ✓All write attempts logged to database with timestamp and outcome
- ✓Integration with Artifact Registry for full audit trail
- ✓Status: PRODUCTION READY. Integrated with Capability 8a.
IMPACT
The word 'saved' means what it's supposed to mean. Never a silent failure.
TECHNICAL IMPLEMENTATION
Hook-based file system checks. Atomic write verification. SHA-256 hashing of file contents.
Multi-Developer Coordination
THE PROBLEM
36.9% failure rate above 4 concurrent agents. No shared awareness. File overwrites nobody sees until the merge. Main branch edits that deploy to production unnoticed.
WHAT WE SOLVED
- ✓Real-time session registry tracks every active Claude Code instance
- ✓File overlap detection warns when two agents approach the same file
- ✓GitHub webhooks sync PR events in real time
- ✓Main branch warnings fire on every prompt when you're on main
- ✓Step-by-step rebase instructions injected automatically on conflicts
- ✓Merge safety prediction before committing
IMPACT
10 agents. Zero merge surprises. Tested to 10+ concurrent developers.
TECHNICAL IMPLEMENTATION
SQLite session registry. Webhook signature verification. Non-blocking file overlap queries.
Issue Tracker
THE PROBLEM
You find a bug. You ask Claude to track it. It says 'noted.' The session closes. The bug is gone. There's no ticket, no status, no memory it ever existed.
WHAT WE SOLVED
- ✓Issues are first-class persistent objects in SQLite (not notes in sessions)
- ✓Each issue has: auto-incrementing ID, title, severity, status, blocking relationships
- ✓Issues persist until explicitly closed — survive reboots and session changes
- ✓All open issues for current project injected at SessionStart
- ✓Full comment history and session trail for every issue
- ✓Status: PRODUCTION READY. Integrated with Capability 8a/b.
IMPACT
Your prod bug list survives every reboot, every session change, every VS Code restart.
TECHNICAL IMPLEMENTATION
SQLite with foreign keys for issue relationships. Timestamp tracking. Relational audit log.
Decision Log
THE PROBLEM
'We use Server Actions, not API routes.' Six sessions later, Claude suggests API routes. Someone spends an hour going down the wrong path. The original decision existed only in a session that closed months ago.
WHAT WE SOLVED
- ✓Decisions are structured records with: summary, full rationale, alternatives considered
- ✓Four tiers: axiom (foundational), strategy (architectural), pattern (implementation), preference (style)
- ✓Decisions can supersede earlier ones — full audit trail maintained
- ✓Keyword search surfaces relevant decisions automatically when similar topics arise
- ✓Every decision tagged with session, timestamp, and decision-maker
- ✓Status: PRODUCTION READY. Integrated with Capability 4 smart injection.
IMPACT
'Why did we do it this way?' has a permanent, searchable answer.
TECHNICAL IMPLEMENTATION
Semantic keyword indexing. Supersession tracking with full audit trail. Injection scoring against current prompt.
Team Memory & Onboarding
THE PROBLEM
New developer joins. Spends week one asking questions that were answered months ago. Makes mistakes that were fixed before they arrived. Rebuilds understanding that already exists.
WHAT WE SOLVED
- ✓Git-backed onboarding kits stored in `.omniclaude/team-memory/` containing:
- ✓ • Quickstart steps, key files, full tech stack, team conventions
- ✓ • Known gotchas, contact info, decision summaries
- ✓ • Corrections recorded automatically after 3 occurrences become team knowledge
- ✓Memory blocks for architecture, patterns, and standards — version-controlled in git
- ✓Synchronized across the team on every SessionStart
- ✓Status: PRODUCTION READY. Integrated with Capability 1 memory system.
IMPACT
Week 4 productivity on day 1. Knowledge survives team turnover.
TECHNICAL IMPLEMENTATION
Git-backed knowledge base. Consensus learning (3-occurrence threshold). Synchronized memory blocks.
Deployment State Tracker
THE PROBLEM
The crypto.randomUUID bug is fixed in dev. Nobody knows if it's in staging. Nobody knows if it's in prod. Someone opens a new session to 'fix the bug' that was already fixed two days ago.
WHAT WE SOLVED
- ✓Tracks every change's journey across environments: dev → staging → production
- ✓Each deployment record has: change description, affected files, environment target
- ✓Hash verification between transitions — ensures changes propagate correctly
- ✓Status tracking: pending/deployed/rolled-back with full audit trail
- ✓Pending undeployed changes surfaced at every SessionStart
- ✓Status: PRODUCTION READY. Integrated with Capability 8a.
IMPACT
'Is that fix in prod yet?' becomes a one-second lookup. No duplicate fix attempts.
TECHNICAL IMPLEMENTATION
Deployment state machine. Hash verification at each transition. Timestamp-based status tracking.
Persistent 3-Tier Memory
THE PROBLEM
Sessions start blank. Dumping all context into every prompt degrades correctness at ~32K tokens. More memory actually makes things worse.
WHAT WE SOLVED
- ✓Three-tier memory modeled on human cognition:
- ✓ • Working Memory (~500 tokens): Current task, active files, blockers — auto-expires
- ✓ • Episodic Memory: Compressed session summaries, searchable by project/date/topic
- ✓ • Semantic Memory: Distilled knowledge, architecture decisions, patterns, preferences
- ✓Smart injection algorithm scores every memory block against current prompt:
- ✓ • Keyword overlap, recency, modification frequency, task-type matching
- ✓Only blocks above threshold injected — surgical, relevant context. No noise.
IMPACT
30% reduction in token usage. Sessions don't start from zero. Context stays relevant.
TECHNICAL IMPLEMENTATION
Vector-based relevance scoring. Hook integration (SessionStart, UserPromptSubmit). SQLite compression.
Cross-Project Intelligence
THE PROBLEM
Knowledge from Project A never reaches Project B. You change the User schema in Project A. Project B breaks three days later. No one connected the two.
WHAT WE SOLVED
- ✓Dependency graph maps which projects consume or share code
- ✓Shared file detection tracks identical and related files across repos
- ✓Cascade notifications fire when a shared file changes
- ✓Pattern transfer surfaces solutions from one project when similar problem appears in another
- ✓Architecture insights surface breaking changes before they happen
- ✓Cross-repo impact analysis identifies at-risk files automatically
IMPACT
Change one repo. Know what breaks in the others. One team brain across multiple projects.
TECHNICAL IMPLEMENTATION
Dependency graph queries. File hash comparison. Cross-project impact analysis.
Watchdog + Convention Learning
THE PROBLEM
66% of developers say 'almost right' is their top frustration. Circular edits. Repeated mistakes. Conventions corrected once, forgotten by the next session.
WHAT WE SOLVED
- ✓Drift detection identifies circular edits (file region changed 3+ times in session)
- ✓Loop behavior detection (repeating same action with same inputs)
- ✓Hallucination detection (importing packages not in package.json)
- ✓Convention learning captures: explicit statements, user corrections, repeated patterns
- ✓Confidence-scored and stored permanently — enforced team-wide
- ✓Once learned, conventions prevent the mistake from ever happening again
IMPACT
Correct it once. Never correct it again. For anyone on the team.
TECHNICAL IMPLEMENTATION
Transcript parsing. Pattern matching on file edits. Confidence decay analysis.
Context Engineering
THE PROBLEM
Even with 1M token windows, correctness drops at ~32K tokens. More context isn't better. Token costs explode.
WHAT WE SOLVED
- ✓Intent parsing detects task type: bugfix/feature/refactor/test/config
- ✓Dynamic token budgeting: trivial tasks get 800 tokens, complex tasks get 3,500
- ✓Continuity blocks let multi-day tasks resume with full context preserved
- ✓Prefetch hints suggest which files will likely be needed next
- ✓Smart injection from Capability 1 memory powers all context decisions
- ✓Token usage monitoring per session and per task type
IMPACT
Token usage down 30%. Fewer retries. Higher first-pass quality.
TECHNICAL IMPLEMENTATION
Intent classification. Dynamic budget allocation. Prefetch prediction.
Session Analytics
THE PROBLEM
91% more time reviewing AI code. 29% trust despite 80% usage. No visibility into which task types work well and which don't.
WHAT WE SOLVED
- ✓Session metrics collected automatically: duration, tools used, files modified, errors
- ✓Effectiveness scoring (0-100) on every session and every task
- ✓Struggle detection identifies files and patterns where agent consistently fails
- ✓7-day aggregated rollups with task breakdown, success rates, peak productivity hours
- ✓Which AI tasks save you time? Where do you spend extra review time?
- ✓Data-driven decisions on where AI helps your team and where it doesn't
IMPACT
Visible ROI. Data-driven decisions on how to use Claude Code effectively.
TECHNICAL IMPLEMENTATION
Time-series metrics collection. Task-type classification. Aggregation queries.
How These Features Organize Into Capabilities
These 12 capabilities are delivered in 8 capabilities. Starting with work guarantees and coordination, then adding learning, safety, and team intelligence.