docs(ip-audit): record cross-repo similarity audit and repeat recipe

Ran jscpd (token-level clone detector) cross-comparing src/ against the
Claude Code leaked source at ~/claude-code-source/src. Zero cross-repo
clones at default sensitivity (min-lines 5, min-tokens 30) and at strict
mode (min-lines 3, min-tokens 20). Also grepped for 14 distinctive CC
phrases — zero hits. Documented the method, the result, and the recipe
for re-running so future contributors can verify before adding code
that touches surfaces where CC has a counterpart.

Author: halfaipg

.settings/README.md

@@ -8,6 +8,7 @@ and you'll know enough to ship code:
 2. **[architecture.md](architecture.md)** — what's actually in `src/`
 3. **[extending.md](extending.md)** — adding a tool, slash command, or provider
 4. **[testing.md](testing.md)** — how to write tests that catch real bugs
+5. **[ip-audit.md](ip-audit.md)** — how we verify independence from Claude Code's leaked source
 
 If you only have 5 minutes, read `tenets.md`.
 

.settings/ip-audit.md

@@ -0,0 +1,142 @@
+# IP audit — independence from Claude Code source
+
+This is a record of the cross-repo similarity audit we ran to confirm
+codebase-cli contains no copy-paste from the leaked Claude Code source.
+Repeat the audit any time you're considering using CC's source as
+architectural reference for a new feature.
+
+## Method
+
+Three layers, smallest noise → largest:
+
+1. **Token-level clone detection** with `jscpd` (open-source, MIT). Catches
+   exact copies, near-copies (whitespace/identifier changes), and
+   re-indented copies. Doesn't catch high-level algorithmic similarity —
+   that's intentional, because the same algorithm written independently
+   isn't infringement.
+
+2. **Distinctive-phrase grep**. Hand-picked sentences from CC's source
+   that would only appear if we copied them verbatim — prompt openings,
+   characteristic comments, structural markers.
+
+3. **Manual review of high-overlap surfaces**. The places where copy is
+   most tempting: system prompts, tool descriptions, slash-command help
+   text, error messages.
+
+## Last run
+
+**Date:** 2026-05-13
+**CC source path:** `~/claude-code-source/src` (leaked source repo)
+**Our path:** `src/`
+
+### Layer 1 — `jscpd`
+
+```
+npx jscpd@4.0.5 us cc --min-lines 5 --min-tokens 30 \
+  --format "javascript,typescript,jsx,tsx" \
+  --reporters json --output ./report
+```
+
+Then filter the JSON to clones where one side lives in `us/` and the other
+in `cc/` (the default report mixes intra- and inter-repo clones).
+
+**Result:** **0 cross-repo clones** at default sensitivity.
+
+Re-ran tighter:
+
+```
+--min-lines 3 --min-tokens 20 --mode strict
+```
+
+**Result:** **0 cross-repo clones** at strict mode with looser thresholds.
+
+### Layer 2 — distinctive-phrase grep
+
+Phrases checked (each chosen from CC's source as something only their
+codebase would contain):
+
+- `Anthropic's official CLI`
+- `demonstrate thoroughness`
+- `gold-plate`
+- `Mark it as in_progress BEFORE beginning work`
+- `Mark it as completed and add any new follow-up tasks`
+- `track progress, organize complex tasks`
+- `Use this tool proactively`
+- `If completed, you should not mark`
+- `ONLY mark a task as completed when you have`
+- `file search specialist`
+- `verification specialist`
+- `elite AI agent architect`
+- `forked worker process`
+- `Claude guide agent`
+
+**Result:** 0 hits across all phrases.
+
+### Layer 3 — manual review
+
+| Surface | CC location | Our location | Outcome |
+|---|---|---|---|
+| Main system prompt | `src/context.ts` (`getSystemPrompt`) | `src/agent/system-prompt.ts` (`buildSystemPrompt`) | Opens differently ("You are codebase, a CLI coding agent" vs "You are Claude Code, Anthropic's official CLI for Claude"). Task-checklist section *covers the same behavioral concept* as CC's TodoWriteTool prompt (one-in-progress, complete-immediately), but the actual wording is paraphrased. Concept is a generic task-management pattern, not protectable. |
+| Prompt suggestion | `src/commands/AutoCompleteCommand` (CC's variant) | `src/agent/prompt-suggestion.ts` | Explicitly noted in our source code: "Claude Code uses a similar idea with different words; we're not copying that text." |
+| Tool descriptions | `src/tools/*/prompt.ts` | inline in `src/tools/*.ts` | Different structure (CC uses bullet lists, we use headings + bullets) and different wording. Sampled GlobTool: CC says "Fast file pattern matching tool that works with any codebase size" — we say "Find files matching a glob pattern." |
+| Paste placeholder format | `src/history.ts` (`formatPastedTextRef`) | `src/ui/input-state.ts` (`formatPastePlaceholder`) | CC: `[Pasted text #1 +10 lines]`. Ours: `[Pasted #1 · 3 lines]`. Different function name, different file, different format. |
+
+## Concepts we adopted
+
+These are *patterns* — not protectable. We re-implemented each from scratch
+with independent wording / structure:
+
+- Slash-command system with typo suggestions
+- Collapsed-read groups for tool-call rendering
+- Paste placeholders (substitute long content with a side-mapped reference)
+- OSC 8 hyperlinks for file paths
+- OSC 9;4 terminal progress notifications
+- Tool-call status spinners
+- `!cmd` shell escape
+- `@path` file attachments
+- Multi-line input via `\<Enter>`
+- Plan mode as a pre-execution Q&A gate
+- One spinner-state-per-action UI
+
+## Things to NOT do going forward
+
+- Don't read CC's source for *new* feature inspiration. We've already
+  taken what's useful as a benchmark; further reading creates fresh
+  derivation risk for new code.
+- If a CC feature is genuinely better than what we'd design independently,
+  describe it from memory / behavior — not from re-reading the source.
+- Treat their source as evidence-of-prior-art only ("yes, this UX exists
+  and was shipped publicly"), not as an implementation template.
+
+## Repeating this audit
+
+```sh
+# 1. Token-level clones
+mkdir -p /tmp/ipcheck
+cp -r src /tmp/ipcheck/us
+cp -r ~/claude-code-source/src /tmp/ipcheck/cc
+cd /tmp/ipcheck && npx jscpd@4.0.5 us cc \
+  --min-lines 5 --min-tokens 30 \
+  --format "javascript,typescript,jsx,tsx" \
+  --reporters json --output ./report --silent
+
+# 2. Filter to cross-repo only
+node -e "
+const r = require('./report/jscpd-report.json');
+const cross = r.duplicates.filter(d =>
+  (d.firstFile.name.includes('/us/') && d.secondFile.name.includes('/cc/')) ||
+  (d.firstFile.name.includes('/cc/') && d.secondFile.name.includes('/us/'))
+);
+console.log('Cross-repo clones:', cross.length);
+"
+
+# 3. Phrase scan (in repo root)
+for p in "Anthropic's official CLI" "demonstrate thoroughness" "gold-plate" \
+         "Use this tool proactively" "file search specialist" \
+         "elite AI agent architect"; do
+  grep -rc "$p" src/ 2>/dev/null | grep -v ':0$' || echo "0 hits | $p"
+done
+```
+
+If the audit ever reports cross-repo clones, treat that as a real finding —
+read the matched ranges and rewrite our side with independent wording.