Jonathan Check v2 — Response Oracle

This skill predicts YOUR reaction — whatever person you're actually working with. The skill id kept "jonathan" from where it was built and battle-tested, but what it does is generic: build a model of one specific person's real reactions to agent work, then ask it "what would they say to this?" before you present anything. Run it for the person you actually work with.

Before declaring work done, ask the oracle what the person you're working with would actually say to your output. One example setup queries a NotebookLM notebook holding thousands of real conversations between agents and that person — their actual words, corrections, praise, frustration, and patterns — so there's no truncation limit and no small-embedding-model bottleneck. If you've built the equivalent for yourself (see "Setup" below), the same approach applies to your own notebook, built from your own history.

If you haven't set this up yet

This oracle needs a corpus of your own past reactions to agents — it doesn't exist until you build it. Check first: does the switches file have a notebook id configured for this skill (see /alignment-harness:harness-setup)? If not:

1. Say so plainly: "I don't have a notebook built from your own history yet for this check — want me to build one? It reads your own Claude Code sessions on this machine (~/.claude/projects/*/*.jsonl); nothing leaves your machine until you approve what gets uploaded."
2. If they say yes, extract agent-message → your-real-next-reply pairs from your session history, weighting corrections and pushback more heavily (that's the signal this check actually needs), show a preview (count + date range) before uploading anything, then upload to whatever oracle tool you use and save the resulting id to the switches file.
3. Meanwhile, and always as a fallback if you decide not to build one: run the check anyway, using a general "demanding reviewer" rubric instead of a personal one, and label it clearly as uncalibrated:
   • Is the claim of "done" backed by actual run output, not just code that looks right?
   • Does the output name its own assumptions, or does it quietly assume?
   • Would a skeptical reviewer ask "how do you know this works" and get a real answer?
   • Does the explanation use jargon a non-technical reader can't parse?
   • Is there a simpler way to say what changed, in terms of what a real user experiences?
   • Did anything get scoped down or skipped without saying so out loud?
   • Is the certainty stated honestly, or does confident phrasing cover a gap?

Never fabricate a "they would say..." line when no query happened and no rubric was applied — the label ("uncalibrated" vs "from your own history") always has to be honest.

Why v2 is Better Than v1

	v1 (local keyword predictor)	v2 (semantic oracle)
Retrieval	Small local embedding model, truncates long input	Full semantic retrieval, no truncation
Synthesis	Model called with a handful of similar examples	Synthesizes across the whole corpus
Citations	None — just returns a prediction	Every claim can cite specific conversations
Principles	Not included	Can include your own standing principles/index
Setup	Requires a local embedding pipeline	One query command once the notebook exists

When to Use

• Before saying "done", "completed", "shipped", "ready"
• Before presenting work to the human
• When you want to anticipate what they will challenge
• When deciding how to frame your output

How to Query (once you have a notebook configured)

Quick prediction (one command):

nlm notebook query <your-notebook-id> \
  "An agent just told the person: '[paste your output here]'. Based on the historical conversations, what would they most likely respond with? Predict their actual words, tone, and what they would challenge." \
  --profile <your-profile>

Structured prediction (for governer score >= 60):

nlm notebook query <your-notebook-id> \
  "TASK: [what was built]
AGENT OUTPUT: [paste your full output]
EVIDENCE PROVIDED: [what proof you showed]
ASSUMPTIONS MADE: [list them]

Based on the historical conversations, predict:
1. What would they say first?
2. What would they challenge?
3. What evidence would they demand?
4. What tone would they use (satisfied, corrective, frustrated)?
5. What specific phrases would they use (cite real examples from the data)?" \
  --profile <your-profile>

Via MCP (if you have the NotebookLM MCP connected):

mcp__notebooklm__query_notebook({
  notebook_id: "<your-notebook-id>",
  profile: "<your-profile>",
  question: "your query"
})

How to Present Results

Before your output, print ## JONATHAN_CHECK on its own line. After your output is complete, print ## END_JONATHAN_CHECK on its own line. These markers enable automated extraction of these predictions if you've wired up a flywheel-style data store for them (see flywheel-consultant).

## JONATHAN_CHECK
🧠 ── Response Check v2 ──────────────────────────
📌 Work: "{what you built}"

💬 Predicted response:
"{the oracle's prediction — or, if uncalibrated, the general rubric's read}"

📋 Predicted challenges:
  1. {challenge} — addressing: {your evidence or fix}
  2. {challenge} — addressing: {your evidence or fix}

🔮 Confidence signals:
  - {N} citations from real conversations (or: "uncalibrated — general rubric, no personal history queried")
  - Tone: {satisfied | corrective | frustrated}
───────────────────────────────────────────────────
## END_JONATHAN_CHECK

Addressing Challenges

For each predicted challenge:

• ✅ Already handled: Show the specific evidence
• 🔧 Need to fix: Fix it, then re-query to verify
• ⏭️ Not applicable: Explain honestly why

Only declare done when every challenge is ✅.

Proportional Depth

• Score < 30: Quick prediction, skim response, move on
• Score 30-59: Full prediction, address top 3 challenges with evidence
• Score 60-79: Structured prediction, address ALL challenges
• Score 80+: Structured prediction + follow-up query: "If the agent then provided [your evidence], would they be satisfied or push further?"

Notebook Details (example setup — yours will differ once you build one)

• Notebook ID: configured value, kept in the switches file, never hardcoded here
• Profile: whatever profile name you set up
• Sources: in this example build, 45 (43 conversation batches + an evaluator rubric + a principles index)
• Data: in this example build, 8,562 real agent↔person conversation pairs — yours starts at however many sessions you have and grows from there; there's no known minimum for it to start being useful, so don't wait for a large corpus to begin using it uncalibrated-then-upgrading

Upgrade: jonathan-check3 (Full-Context Oracle Loop)

/jonathan-check3 (if installed) extends this skill with:

• All extracted session intelligence (coherence checks, reflect outputs, align sessions, skill sequences, compaction intents, scope declarations) — not just conversation pairs
• Autonomous loop — re-queries after each action until oracle signals SCOPE_COMPLETE
• Next-action prediction — doesn't just predict their response, predicts the next step to take

When to use check3 vs check2:

• Use check2 (this skill) — one-shot gate before presenting work to the human
• Use check3 — when running autonomously, or as the steering loop for high-stakes/complex scopes

Invoke: Skill({ skill: "jonathan-check3" })