This skill predicts YOUR reaction — whatever person you're actually working with.

Check v3 — God-Mode Oracle Loop

This skill keeps its original id because that's what it was built for and tested against: a real record of one person's corrections to agents over thousands of sessions. Everything it does generalizes to you — your own notebook, built from your own sessions — once you set it up. Until then, it runs on an honest fallback (see below), never on a guess dressed up as your judgment.

jonathan-check2 predicts what the person would say based on a large corpus of past agent↔person conversations. jonathan-check3 does that AND predicts your next action, then loops until the oracle says the scope is done.

The full version is backed by all extracted session intelligence for whoever the notebook was built from:

• coherence check blocks (real-time alignment decisions)
• reflect outputs (self-reflection and gap analysis)
• align session outputs (intent mapping sessions)
• skill-sequence records (context → skill order → completion)
• compaction intent records (parent intent → child UX intent)
• scope declaration blocks (agent contracts before implementation)
• risk/governance scores, session IDs, dates across all of the above

Setup status — check this first

This piece needs a NotebookLM notebook (Google's tool that answers questions from documents you upload) built from your own history before it can predict YOUR reaction. Check whether that's done:

1. Is a notebook ID configured? Run alignment-harness config path and look for a notebook id under this skill's setup. If none is set, it isn't configured.
2. If one is set, test it: nlm notebook query <notebook-id> "test" --profile <your-profile>. An answer that isn't an error means it's reachable.
3. If neither exists, you have no oracle yet — go to No notebook yet: the fallback, below, and consider running /alignment-harness:harness-setup to build one from your own transcripts.

The Loop (once you have a notebook)

Step 1 — Present current state to the oracle

nlm notebook query [YOUR_NOTEBOOK_ID] \
  "CURRENT SCOPE: [one sentence — what we are trying to accomplish]
WORK DONE SO FAR: [what has been built or decided]
RISK/GOVERNANCE SCORE: [N/100, from /alignment-harness:governer if you have it, otherwise omit]
OPEN QUESTIONS: [anything uncertain]

Based on all the session history, skill sequences, and alignment patterns in this data:
1. What would I most likely say about this state of work?
2. What is the single most important next action to take right now?
3. Is the scope complete? If yes, say SCOPE_COMPLETE. If no, say SCOPE_INCOMPLETE and give the next step." \
  --profile [your-profile]

Step 2 — Print the oracle's output observably

Before your output, print ## JONATHAN_CHECK_V3 on its own line. After your output is complete, print ## END_JONATHAN_CHECK_V3 on its own line. These enable automated extraction of oracle loop iterations for later reuse (see /alignment-harness:harness-setup if you want to rebuild your notebook periodically from new sessions).

## JONATHAN_CHECK_V3
🔮 ── Check v3 Oracle ───────────────────
📌 Scope: "{current scope}"
📊 Risk/governance score: {N}/100 (if available)

💬 What the person would likely say:
"{oracle's predicted response}"

⚡ Next action:
"{oracle's recommended next step}"

🏁 Scope status: SCOPE_COMPLETE / SCOPE_INCOMPLETE
────────────────────────────────────────────────
## END_JONATHAN_CHECK_V3

Step 3 — Execute the next action

If SCOPE_INCOMPLETE: execute the oracle's recommended next step, then loop back to Step 1. If SCOPE_COMPLETE: stop. Present the finished work to the person.

While your own notebook is new or small, don't let SCOPE_COMPLETE end the loop silently — surface it to the person and let them confirm before you present the work as done. A notebook built from only a few sessions can call something finished too early; a human confirmation step here costs little and catches that.

Step 4 — Re-query after each action

After executing the action, re-query the oracle with the updated state. Keep looping. Print every oracle response. Never silently skip a loop.

No notebook yet: the fallback

If you have no notebook configured (most new installs), don't skip this check — do it honestly instead:

1. Say plainly, in your output: "This check predicts how you'd react to my work and what you'd want next, based on how you've corrected agents before. It isn't connected to a notebook yet."
2. Reason from what you actually have: your own past corrections to agents in this project (grep ~/.claude/projects/*/*.jsonl for places where the person corrected or redirected an agent), any stated preferences in this project's CLAUDE.md or memory files, and the actual state of the current work.
3. Write out your own best prediction of the person's reaction and the next step, clearly labelled as your guess, not their history: "My prediction (not backed by your own oracle yet):" — never print SCOPE_COMPLETE under this fallback without saying it's unverified, and never present it as equivalent to the real oracle's answer.
4. If you want the full version, offer to run /alignment-harness:harness-setup, which walks through: reading your own transcripts, showing you what it found before uploading anything, creating the notebook, and writing the notebook ID and your chosen dials (max rounds per run, whether SCOPE_COMPLETE needs your confirmation) into a config file rather than this skill file.

Example setup (opt-in starter — replace with your own)

One example version was built from roughly 8,500 real agent conversations plus over a thousand extracted "coherence check" blocks, hundreds of reflection and alignment-session outputs, and dozens of skill-sequence records — all that person's own material, uploaded to a notebook only they can query. None of that data ships with this plugin. If you want a quick taste of how the loop behaves before building your own, /alignment-harness:harness-setup can point you to a small, clearly-labelled sample of published reasoning from that example (never raw transcripts, never anyone else's names, never business specifics) — but treat any answer built from someone else's history as a demo of the mechanism, not a prediction of what YOU would say, and require your own confirmation before treating its SCOPE_COMPLETE as real.

When to Use

• After completing a major chunk of work and needing to know what's next
• As a completion gate before declaring work done (replaces jonathan-check2 for high-stakes work)
• When running autonomously — use this as the steering loop

Full Autonomous Loop Example

/jonathan-check3

→ Oracle: "scope incomplete, build the skill-sequence corpus first"
→ Agent: builds skill-sequence-corpus.md
→ Oracle: "scope incomplete, upload to your notebook source"
→ Agent: uploads all files
→ Oracle: "scope incomplete, wire up the next dependent piece"
→ Agent: does it
→ Oracle: "scope incomplete, document what changed"
→ Agent: documents it
→ Oracle: "SCOPE_COMPLETE — all pieces built, uploaded, and documented"
→ Agent: stops, presents to human

Difference from jonathan-check2

	check2	check3
Data source	large corpus of real agent↔person conversations	Everything above PLUS all session intelligence
Output	Predicted response + challenges	Predicted response + next action + loop
Mode	One-shot gate	Autonomous steering loop
Scope signal	Not tracked	Explicitly signals SCOPE_COMPLETE
When to use	Before presenting work	When running autonomously

Query pattern (adapt to whatever oracle tool you have configured)

mcp__notebooklm__query_notebook({
  notebook_id: "[YOUR_NOTEBOOK_ID]",
  profile: "[your-profile]",
  question: "CURRENT SCOPE: ... WORK DONE: ... What would I say? What's the next step? SCOPE_COMPLETE or SCOPE_INCOMPLETE?"
})

If you don't have a NotebookLM MCP server or the nlm CLI configured, use the fallback in the section above instead of skipping this check.