Copy-first recovery · Operator-first proof · Builder lane second

Prove a copied Apple Notes case path in 4 commands before you touch a real case.

NoteStore Lab is a macOS Apple Notes recovery and review toolkit built around copied case roots, reviewable outputs, bounded AI assistance, and a local read-mostly MCP surface. The first story is the operator story: prove the workflow shape, inspect the artifacts, and confirm the host boundary. Builder integrations come after that.

Start in 60 seconds

Run these in order. The sequence is the product story, not just a checklist.

1
notes-recovery demo
See the case-root shape before touching a real copied-evidence run.
2
notes-recovery ai-review --demo
Watch AI stay on derived artifacts instead of pretending to be the recovery engine.
3
notes-recovery ask-case --demo --question "What should I inspect first?"
Ask one bounded question and inspect the cited evidence refs.
4
notes-recovery doctor
Only then decide whether this host is ready for a real copied-evidence run.

Zero-risk demo AI triage on derived artifacts Evidence-backed case Q&A Doctor preflight before real runs

Core truth: recovery and review stay primary. AI is a bounded review layer, and MCP is a local builder surface that rides on the same case root after the operator proof path is clear.

Follow the 4-command proof path

See the public proof boundary before you move to a real case.

Public-safe demo proof showing copied-evidence case outputs.

One copied-evidence workflow, one timestamped case root, and one review-safe proof surface: backup, recovery, verification, report, AI review, and bounded case Q&A.

Operator lane first

Demo, triage, question, doctor. That path should make sense before any builder wrapper enters the story.

Proof stays inspectable

Manifests, summaries, verification previews, and reports remain the center of gravity.

Use cases LLMs guide Builder guide

First success

4 operator-first steps in under 5 minutes

This is the shortest path from “I just arrived” to “I now trust what this repo is trying to do”.

notes-recovery demo

See one public-safe, timestamped case root with recovery, verification, report, and review artifacts before you touch a real copied case.

notes-recovery ai-review --demo

Generate a synthetic triage summary, top findings, next questions, and artifact priority from derived demo artifacts instead of raw private data.

notes-recovery ask-case --demo ...

Ask one bounded question and get an answer with evidence refs, confidence, uncertainty, and next inspection targets from the same review-safe surface.

notes-recovery doctor

Confirm the host boundary, optional surfaces, and the safest next step before you point the toolkit at a real copied-evidence run.

Curation

Choose your lane after the proof path

This repo works best when it feels like a guided exhibit: the operator story comes first, the AI story sharpens it, and the builder lane only opens after the case-root workflow already feels real.

Operator lane

First-read path for almost everyone

Stay on the public-safe case-root story first. The goal is to understand one workflow, one boundary, and one review surface before you think about integrations.

Builder lane

Only after the workflow feels real

Register the shipped stdio MCP command.
Reuse the same case root in Codex or Claude Code.
Treat distribution and registry surfaces as second-order truth.

Workflow shape

One case, three consumers

The product gets stronger when the same case root supports human review, bounded AI help, and local agents without opening a second data plane.

Operator Prove the copied-evidence workflow once

Start with demo, ai-review --demo, ask-case --demo, then doctor. The repo leaves behind manifests, verification previews, timelines, reports, and one review index instead of ad hoc files.

AI Review Summarize before you dig deeper

ai-review and ask-case sit on derived artifacts first. They rank what to inspect next, cite evidence, and keep the recovery engine separate from the explanation layer.

Local Agent Mount the same case root in Codex or Claude Code

The MCP surface stays local stdio-first, read-mostly, and case-root-centric. That makes it easy to reuse the same review substrate without inventing a hosted platform.

Surfaces

Proof, distribution, and support

Once the first success path lands, these are the three surfaces that stop the repo from feeling hand-wavy: proof, listing truth, and the support contract.

Public proof boundary

See the exact repo-side proof, remote read-back proof, and the manual external tail that still lives in GitHub Settings or platform controls.

Distribution truth

Check which registry and plugin surfaces are shipped, public-ready, or still waiting on official listing read-back.

Support contract

Use the issue route, required report details, and support boundary without guessing which surface the maintainer actually supports.

Positioning

Why AI and MCP users should care

Category	Digital forensics and evidence review for copied Apple Notes case roots.
AI / agent hook	AI-assisted triage, evidence-backed case Q&A, and a local MCP surface that works with Codex / Claude Code style local-agent workflows.
Result	Recover, inspect, question, compare, and safely hand off reviewable outputs without pretending the repo is a hosted autonomy platform.

The repo is intentionally operator-first. AI and MCP matter here because they help people reuse one case root, not because the repo is pretending to be a hosted autonomy platform.

Ecosystem

Current ecosystem fit

Primary fit: MCP, Codex, Claude Code
Secondary / comparison fit: OpenHands, OpenCode
Not a main front-door claim: OpenClaw-specific positioning, hosted portals, generic agent-platform promises

Builder path

Builder path: Codex and Claude Code

Once the operator path is clear, register the shipped stdio MCP entrypoint and point it at a real case root.

Registration command:
.venv/bin/python -m notes_recovery.mcp.server --case-dir ./output/Notes_Forensics_<run_ts>

The exact JSON wrapper depends on the host. The stable part is the command itself plus the case-root-centric, read-mostly contract. This is a builder / local-agent entrypoint, not a hosted API.

The builder guide includes minimal .codex/config.toml and project .mcp.json wrapper examples for this shipped local stdio command.

OpenClaw-style hosts stay in the comparison bucket for now. This repo now ships an OpenClaw-compatible bundle build path, but not a live ClawHub listing or a first-class host-specific contract.

Codex project config

Use the project .codex/config.toml shape and keep the path base honest.

[mcp_servers.notestorelab]
command = "../.venv/bin/python"
args = [
  "-m",
  "notes_recovery.mcp.server",
  "--case-dir",
  "./output/Notes_Forensics_<run_ts>",
]
cwd = ".."

Claude Code project config

Use the project .mcp.json shape and point it at the same shipped local stdio command.

{
  "mcpServers": {
    "notestorelab": {
      "command": ".venv/bin/python",
      "args": [
        "-m",
        "notes_recovery.mcp.server",
        "--case-dir",
        "./output/Notes_Forensics_<run_ts>"
      ]
    }
  }
}

Claude Code	Good fit for the shipped local stdio MCP contract and case-root-centric workflow.
Codex	Good fit for the same local stdio MCP contract. Carry the executable command into the host wrapper you use.
ChatGPT developer mode	Comparison path only. This repo does not ship a hosted or remote MCP deployment.
OpenClaw-style hosts	Compatible bundle path now shipped. Reuse the same local MCP command and the bundled archive build, but do not claim a live ClawHub listing or first-class wrapper without fresh external read-back.

Fastest host smoke: run demo, run ask-case --demo, then register the exact notes_recovery.mcp.server command against one case root.

Signal

Why developers star it

These are the product signals that make the repo feel real once the first proof path has landed.

It is inspectable

The repo gives you one case root, one review index, and one set of review-safe artifacts. You can inspect the outputs first and then let AI or MCP consume the same surfaces.

It is local-first

The workflow stays on macOS, on copies, and on local stdio-first tooling. That is a strong fit for developers who want traceable behavior instead of hosted magic.

It has real AI hooks

ai-review, ask-case, and the MCP server are already shipped. They are not roadmap placeholders or vague AI branding layers.

It does not pretend

No hosted API, no generated client, no generic agent platform promise. The repo is attractive precisely because the boundaries are sharp and the proof is easy to audit.

Reading shelf

Keep reading

Think of this as the shelf behind the front desk: operator path first, then deeper truth, then builder and support surfaces.