cc-anywhere 1.2.0__tar.gz

cc_anywhere-1.2.0/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2025-2026 Abe Couse
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cc_anywhere-1.2.0/PKG-INFO

@@ -0,0 +1,444 @@
+Metadata-Version: 2.4
+Name: cc-anywhere
+Version: 1.2.0
+Summary: Memory built for AI coding. Captures Claude Code, Cowork, Codex, and Gemini CLI sessions into a local SQLite database — pick work back up with context, not guesswork.
+Author: Abe Couse
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/abecouse/cc-anywhere
+Project-URL: Repository, https://github.com/abecouse/cc-anywhere
+Project-URL: Issues, https://github.com/abecouse/cc-anywhere/issues
+Keywords: cc-anywhere,claude-code,codex,ai-memory,ai,sync,developer-tools,productivity,anthropic,cli
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=10.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Dynamic: license-file
+
+# cc-anywhere
+
+**Memory built for AI coding.**  ·  Pick work back up with context, not guesswork.
+
+> I wanted to remember what we discussed about my projects, and couldn't find past discussions, decisions, or feedback. The AI agents also seemed to forget.
+>
+> So I built cc-anywhere — for me, and for them. One memory layer; both audiences read it the same way.
+>
+> — *Abe Couse*
+
+Every Claude Code, Claude Cowork, Codex CLI / Desktop, and Gemini CLI session you run gets captured into a fast local SQLite database with full-text and natural-language search. Then you can ask any future session — Claude, Codex, Gemini, anything that can shell out to a CLI — *"what did we decide about auth last week?"* and get the actual past conversation back.
+
+---
+
+## The 30-second demo
+
+```bash
+pip install cc-anywhere
+cc-anywhere --capture
+cc-anywhere --ask "what did we decide about auth?"
+```
+
+That's the whole thing. The third command searches every Claude Code, Claude Cowork, and Codex session you've ever had on this machine and returns the conversations that match — ranked, with project, speaker, and timestamp.
+
+The first time you run it, search will surface conversations from months ago that you'd half-forgotten. The moment people realize their entire AI coding history just became queryable is the moment this project earns its keep.
+
+### Two query modes — `--ask` routes automatically
+
+```bash
+# Topical recall — name a subject, get the relevant past conversations
+cc-anywhere --ask "what did we decide about pricing"
+
+# Temporal recall — name a time window, get a chronological pull (no keywords needed)
+cc-anywhere --ask "what was I working on today"
+cc-anywhere --ask "this week"
+cc-anywhere --ask "catch me up"
+```
+
+Wide windows (this week / month) return a daily rollup with drill-in hints so you can walk back into a specific day. Narrow windows return a per-session list with previews.
+
+### Usage overview
+
+```bash
+cc-anywhere --usage
+```
+
+Modeled on Claude Code's `/usage` but with longer time horizons (not capped at 30 days), per-project breakdown, per-machine breakdown when sync data is present, and a marathon-sessions view.
+
+### For LLM agents
+
+```bash
+cc-anywhere --llm-guide
+```
+
+Prints the full LLM-facing usage reference (query patterns, drill-in, when *not* to use, code-vs-conversation interplay). Reachable from any cwd, so an agent in any session can fetch it. `LLM-CHEATSHEET.md` at the repo root mirrors the same content for human reading.
+
+---
+
+## Why it exists
+
+AI coding assistants are great at remembering inside a session and unaware of everything before it. ChatGPT memory is locked to ChatGPT. Claude memory is locked to Claude. Codex has no cross-tool memory at all. Vendors won't fix this — siloed memory is a feature of their lock-in, not a bug.
+
+`cc-anywhere` is the local layer that gives that history back to you. User-owned, vendor-neutral, fully on your machine, free.
+
+It also exposes that memory to coding agents. A human can use the CLI directly, or an agent can call `--ask`, `--view`, and `--source` on the user's behalf to recover project context before acting.
+
+Once installed on a machine, any coding agent that can run local shell commands can theoretically use it as a memory layer. Today that means Claude Code and Codex are the concrete first-class examples; other CLI-capable agents can use the same interface as long as they can execute local commands and read the output.
+
+---
+
+## Build order
+
+The product order matters:
+
+1. Nail the CLI
+2. Nail agent integration
+3. Add other surfaces only after the core memory loop feels solid
+
+That keeps the project anchored on the actual engine: local capture, retrieval, and recall that both humans and coding agents can trust.
+
+---
+
+## Install
+
+One command on macOS and Linux (including WSL):
+
+```bash
+pip install cc-anywhere
+cc-anywhere --init
+```
+
+`--init` is idempotent and does three things:
+
+1. Captures every existing Claude Code / Codex / Gemini session into the local SQLite DB and builds the semantic search index.
+2. Wires SessionStart + Stop hooks into `~/.claude/settings.json` so future sessions auto-load past context and capture on exit. Existing hooks are preserved, never replaced.
+3. Sets up an hourly capture safety net (launchd on macOS, cron on Linux).
+
+Open a fresh Claude Code session — recall fires automatically.
+
+### Platform support
+
+| Platform | Install path | Notes |
+|---|---|---|
+| **macOS** | `pip install cc-anywhere && cc-anywhere --init` | Fully automatic. Uses `launchd` for hourly capture. |
+| **Linux** | `pip install cc-anywhere && cc-anywhere --init` | Fully automatic. Uses `crontab` for hourly capture. |
+| **Windows (WSL)** | `pip install cc-anywhere && cc-anywhere --init` (inside WSL) | Identical to Linux. Recommended Windows path. |
+| **Windows (native)** | `pip install cc-anywhere && cc-anywhere --init`, then optional `schtasks` step below | Capture and search work natively. Hourly scheduler needs one manual step. |
+
+### Native Windows: hourly capture step
+
+`--init` configures the hooks and runs the initial capture. For the hourly safety net, run this once in PowerShell (no admin needed):
+
+```powershell
+schtasks /create /sc hourly /tn "cc-anywhere capture" /tr "cc-anywhere --capture" /f
+```
+
+You can skip this entirely — the Stop hook still captures after every Claude Code session ends, which covers most cases. The hourly job is a safety net for long-running sessions where Stop never fires.
+
+### Manual commands work the same on every platform
+
+Every command below is platform-independent:
+
+```bash
+cc-anywhere --ask "what did we decide about auth?"
+cc-anywhere --semantic-search "topic"
+cc-anywhere --capture
+cc-anywhere --sync-archive       # full-history backup
+cc-anywhere --view <chunk_id>
+cc-anywhere --source <chunk_id>
+```
+
+### Requirements
+
+Python 3.8+. Claude Code, Codex CLI, or Gemini CLI installed locally (whichever you use). `git` is required for cross-machine sync but not for local-only use.
+
+`cc-anywhere` is the public-facing command name. `claude-anywhere` continues to work as a compatibility alias for users upgrading from earlier versions.
+
+---
+
+## Tips
+
+Concrete things you might want to do once it's installed.
+
+### Cross-machine sync (via your own private GitHub repo)
+
+Create a private repo on GitHub named `cc-sync` (one-time, free). Then on each machine:
+
+```bash
+cc-anywhere
+# press 's' for setup, enter your GitHub username, accept default repo name
+```
+
+After that:
+
+```bash
+cc-anywhere --sync   # push from this machine
+cc-anywhere --pull   # receive from others
+```
+
+Sync is **manual** — you control when. A 30-day rolling slice goes to the repo per machine.
+
+### Onboarding a fresh machine to your full history
+
+On the *origin* machine (one-time):
+
+```bash
+cc-anywhere --sync-archive
+```
+
+That pushes your **entire** local history (not just 30 days) to the `cc-sync` repo. On the *new* machine:
+
+```bash
+pip install cc-anywhere
+cc-anywhere --init
+cc-anywhere --pull
+```
+
+The archive imports automatically. UUID dedup means you can re-run `--pull` any time without producing duplicates.
+
+### Backing up to an external SSD
+
+```bash
+cc-anywhere --sync-archive --to /Volumes/Backup-SSD/cc-anywhere/
+```
+
+Idempotent — re-running just rewrites the archive with whatever's current. The same command works for any mounted destination.
+
+### Backing up to iCloud / Dropbox / Google Drive / NAS
+
+Same command, different path:
+
+```bash
+# iCloud Drive
+cc-anywhere --sync-archive --to ~/Library/Mobile\ Documents/com~apple~CloudDocs/cc-anywhere/
+
+# Dropbox / Google Drive (via the desktop client's mounted folder)
+cc-anywhere --sync-archive --to ~/Dropbox/cc-anywhere/
+
+# NAS (after you've mounted it as a regular folder)
+cc-anywhere --sync-archive --to /Volumes/NAS-share/cc-anywhere/
+```
+
+Anything that mounts as a regular folder works.
+
+### Automatic backup every Friday
+
+Add a `crontab` entry:
+
+```bash
+0 18 * * 5  /usr/local/bin/cc-anywhere --sync-archive --to /Volumes/Backup-SSD/cc-anywhere/
+```
+
+6pm every Friday. (Replace the path to `cc-anywhere` with whatever `which cc-anywhere` reports on your machine.)
+
+### Checking what's actually captured
+
+```bash
+cc-anywhere --db-stats
+```
+
+Shows session count, message count, project count, DB size, earliest and latest captures.
+
+### Asking your AI to use cc-anywhere mid-session
+
+You usually don't have to. The `SessionStart` hook installed by `--init` auto-loads relevant past context when a Claude Code session begins. But you can also nudge mid-conversation: *"check past decisions on auth"*, and the AI will run `cc-anywhere --ask` for you.
+
+### What's local-only vs. what gets synced
+
+| Stays local | Synced to your `cc-sync` repo |
+|---|---|
+| `~/.cc-anywhere-sessions.db` (full SQLite DB) | A 30-day rolling slice per machine via `--sync` |
+| Semantic search index | The full archive snapshot via `--sync-archive` |
+| Raw JSONL transcripts on disk | — |
+
+`--sync` is for cross-machine continuity; `--sync-archive` is for off-disk backup and onboarding new machines. Both are manual; nothing leaves your machine without a command you ran.
+
+### Build a permanent history — before it's gone
+
+Without cc-anywhere, your AI coding history is at the mercy of each tool's retention policy. Claude Code's `cleanupPeriodDays` defaults to 30 days; Codex and Gemini have their own retention behaviors. **Anything pruned before cc-anywhere captures it is gone forever.** No recovery.
+
+With cc-anywhere installed, every captured conversation is persisted permanently in your local SQLite database, independent of any tool's retention. You're actively building a long-term archive of your project work — preserved across sessions, machines, and assistants. The earlier you install, the more history you keep.
+
+If you want maximum coverage of your existing data before cc-anywhere's first run, bump `cleanupPeriodDays` in `~/.claude/settings.json` to a larger value (e.g. `365`) first.
+
+### What's not yet supported
+
+Direct integrations with cloud-storage APIs (Cloudflare R2, S3, Backblaze B2) are planned but not yet implemented. Until then, mount the cloud storage as a folder on your machine and use the filesystem path with `--sync-archive --to <path>`.
+
+---
+
+## Presently supported
+
+Today there are two different support questions:
+
+1. **Which tools can `cc-anywhere` capture memory from?**
+2. **Which tools can call `cc-anywhere` after it is installed?**
+
+### Capture sources supported today
+
+These transcript sources are captured and indexed now:
+
+| Source | Status | Notes |
+|---|---|---|
+| Claude Code | ✅ | Main session transcripts under `~/.claude/projects/*.jsonl` |
+| Claude Cowork | ✅ | Local-agent transcripts under `~/Library/Application Support/Claude/local-agent-mode-sessions/**/.claude/projects/*/*.jsonl` |
+| Codex CLI / Codex Desktop | ✅ | Rollout logs under `~/.codex/sessions/.../*.jsonl` |
+
+### Search assistants supported today
+
+These tools can use `cc-anywhere` as a search assistant and memory layer today, as long as they can run local shell commands and read the output:
+
+| Tool | Status | Notes |
+|---|---|---|
+| Claude Code | ✅ | Can call `--ask`, `--db-search`, `--semantic-search`, `--view`, and `--source` directly or through slash-command / memory workflows |
+| Codex CLI | ✅ | Can call the same commands directly; the `threaded` skill makes this feel automatic |
+| Codex Desktop | ✅ | Same local CLI contract as Codex CLI |
+| Gemini CLI and other CLI-capable coding agents | In theory ✅ | They can use `cc-anywhere` as a search assistant once installed; capture support depends on their own local transcript format |
+
+### Not captured yet
+
+These are intentionally not first-class capture sources yet:
+
+| Source | Status |
+|---|---|
+| Claude Code subagents (`*/subagents/*.jsonl`) | ⏳ planned |
+| Codex child/agent traces outside rollout logs | ⏳ investigate |
+| Cursor | ⏳ planned |
+| Continue.dev | ⏳ planned |
+| GitHub Copilot Chat | ⏳ planned |
+
+The important distinction is that **calling** `cc-anywhere` and **being captured by** `cc-anywhere` are different things. A tool might be able to use it as a search assistant today even if we do not yet ingest that tool's own transcript history.
+
+---
+
+## First five minutes
+
+```bash
+# Snapshot every Claude Code + Codex session into the local DB
+cc-anywhere --capture
+
+# Build the natural-language search index
+cc-anywhere --index-semantic
+
+# Search by keyword
+cc-anywhere --db-search "verification customer"
+
+# Or in natural language
+cc-anywhere --ask "when did we discuss the MCP wrapper?"
+
+# Drill into a result, then jump back to the raw transcript source
+cc-anywhere --view <chunk_id>
+cc-anywhere --source <chunk_id>
+
+# See your project list
+cc-anywhere --list
+
+# Or open the interactive dashboard
+cc-anywhere
+```
+
+That's the whole CLI surface that matters for daily use. The same commands also form a retrieval interface for coding agents.
+
+---
+
+## Make it automatic
+
+The single highest-leverage move is wiring `--capture` and `--index-semantic` into Claude Code's Stop hook so the index stays current without you thinking about it. Append to your Stop hook script (e.g. `~/.claude/scripts/snapshot-memory.sh`):
+
+```bash
+if command -v cc-anywhere >/dev/null 2>&1; then
+  cc-anywhere --capture        >> "$HOME/.claude-memory-archive/.last-capture.log"        2>&1 || true
+  cc-anywhere --index-semantic >> "$HOME/.claude-memory-archive/.last-index-semantic.log" 2>&1 || true
+fi
+```
+
+For long-running sessions that never end cleanly, also add a hourly launchd / cron job that runs the same two commands. Both steps are incremental — only new messages are processed — so the cost stays small as your corpus grows.
+
+---
+
+## Pair with Claude Code and Codex
+
+Three custom slash commands at `~/.claude/commands/` give you `/digest`, `/projects`, and `/memory <query>` from any Claude Code session.
+
+A Codex skill at `~/.codex/skills/threaded/SKILL.md` does the same for Codex sessions — phrases like *"what did we decide last week?"* trigger the search automatically.
+
+Both surfaces call the same local database. Memory written by one assistant is visible to the other.
+
+The important architectural point is that agents do not need to inspect SQLite directly. They can use:
+
+```bash
+cc-anywhere --ask "what did we decide about auth?"
+cc-anywhere --view <chunk_id>
+cc-anywhere --source <chunk_id>
+```
+
+That makes `cc-anywhere` both a human CLI and a stable memory interface for coding agents.
+
+In practical terms, any coding agent with local CLI access can call that interface after install. The retrieval contract is vendor-neutral even though the current capture sources started with Claude Code and Codex.
+
+---
+
+## What it captures
+
+| Source | Status |
+|---|---|
+| Claude Code (`~/.claude/projects/*.jsonl`) | ✅ |
+| Claude Cowork (`~/Library/Application Support/Claude/local-agent-mode-sessions/**/.claude/projects/*/*.jsonl`) | ✅ |
+| Codex CLI (`~/.codex/sessions/.../*.jsonl`) | ✅ |
+| Claude Code subagents (`*/subagents/*.jsonl`) | ⏳ planned |
+| Codex child/agent traces outside rollout logs | ⏳ investigate |
+| Cursor | ⏳ planned |
+| Continue.dev | ⏳ planned |
+| GitHub Copilot Chat | ⏳ planned |
+
+Capture is incremental, file-offset tracked, and resilient to context compaction (the JSONL on disk is append-only — `/compact` does not destroy history, so the full record stays searchable).
+
+Tool calls and their outputs are not captured — text only — to keep the index focused on what humans wrote and what assistants said in prose.
+
+Subagent transcripts are a future expansion. The current capture path indexes the main Claude Code session logs, Claude Cowork local-agent transcripts, and Codex rollout logs; nested Claude Code `subagents/*.jsonl` files and any Codex child-agent traces stored outside the rollout logs are intentionally left for a later pass so the opener stays focused.
+
+---
+
+## What it does not do
+
+- **It does not replace the AI's own memory.** It is the layer underneath that — the one that survives context windows, vendor changes, and machine reinstalls.
+- **It does not send your data anywhere by default.** Everything is local. If you opt into sync, only lightweight metadata travels (full conversations stay on your machine).
+- **It does not require any AI provider account.** It reads what's already on disk.
+
+---
+
+## Beyond the basics
+
+Once the daily loop is working, the dashboard, sync, digests, and architecture are useful in this order:
+
+- **`cc-anywhere --weekly`** / **`--monthly`** — activity reports with project breakdowns and daily-activity bar charts
+- **`cc-anywhere --setup`** — wires up cross-machine sync via a private GitHub repo (lightweight metadata only)
+- **`cc-anywhere`** (no args) — interactive dashboard with pickup-prompt generation
+- **`cc-anywhere --backfill-sources`** — links older DB rows to their raw JSONL transcript paths so `--source` works on the back catalogue
+- **`cc-anywhere --index-semantic --rebuild`** — opt-in full re-index (rare; use after corruption)
+
+For the layered architecture (Layer 1 capture sources → Layer 2 archive → Layer 3 this tool → Layer 4 Threaded the deployed edition → Layer 5 surfaces), see the architecture document at `~/Documents/Projects/MEMORY-ARCHITECTURE.md`.
+
+---
+
+## Status
+
+- **Version:** 1.1.0
+- **License:** Apache-2.0
+- **Source:** [github.com/abecouse/cc-anywhere](https://github.com/abecouse/cc-anywhere)
+- **Author:** Abe Couse
+
+Threaded — the deployed, multi-machine, MCP-exposed version of this same memory layer — is the next album. `cc-anywhere` is the live local edition. Same chorus.