ai-collab-open-system 0.1.0

package/.aict/handoff/FAILURE_MODES.md

@@ -0,0 +1,40 @@
+# Handoff Common Failure Modes
+
+## Purpose
+
+Transfer current state, decisions, evidence, blockers, and next actions to another session or tool without replaying the whole conversation.
+
+## When to use
+
+Read this before trusting a handoff artifact.
+
+## Input shape
+
+The artifact plus the original context and acceptance card.
+
+## Output shape
+
+A short list of risks to fix before reuse.
+
+## Copy-paste prompt
+
+Ask your AI tool: "Check this handoff artifact against the failure modes below and name the first concrete fix."
+
+## Blank template
+
+Use `TEMPLATE.md` to rewrite the artifact.
+
+## Filled synthetic example
+
+Use `EXAMPLE.synthetic.md` to compare a safe example.
+
+## Common failure modes
+
+- Writing a narrative summary instead of a resumable state card.
+- Not separating completed from unverified.
+- Omitting blockers and causing the next assistant to guess.
+- Leaving no exact next action.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+Paste this file after the artifact and ask for findings ordered by risk.

package/.aict/handoff/PROMPT.md

@@ -0,0 +1,47 @@
+# Handoff Prompt
+
+## Purpose
+
+Transfer current state, decisions, evidence, blockers, and next actions to another session or tool without replaying the whole conversation.
+
+## When to use
+
+Use before stopping, switching tools, delegating to another assistant, or after any work that may need continuation.
+
+## Input shape
+
+Goal, current status, completed work, changed files or artifacts, decisions, verification evidence, blockers, and next action.
+
+## Output shape
+
+A short handoff note that separates done, pending, blocked, and unverified work.
+
+## Copy-paste prompt
+
+```text
+Create a handoff note for the next AI session. Include goal, current state, completed work, pending work, blockers, decisions, verification evidence, and the exact next action. Label unverified claims.
+
+Input:
+[paste your redacted task material here]
+
+Output shape:
+A short handoff note that separates done, pending, blocked, and unverified work.
+
+Rules:
+- Keep private material local and redacted.
+- Label facts and assumptions.
+- If information is missing, ask at most three concrete questions.
+- Make the result usable in Claude Code / Codex / Cursor / Windsurf / Copilot / Cline.
+```
+
+## Blank template
+
+Use `TEMPLATE.md`.
+
+## Filled synthetic example
+
+Use `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+Use `FAILURE_MODES.md`.

package/.aict/handoff/README.md

@@ -0,0 +1,44 @@
+# Handoff
+
+How the next session resumes without restarting.
+
+中文：给下一棒留一个能直接接上的交接卡。
+
+## Purpose
+
+Transfer current state, decisions, evidence, blockers, and next actions to another session or tool without replaying the whole conversation.
+
+## When to use
+
+Use before stopping, switching tools, delegating to another assistant, or after any work that may need continuation.
+
+## Input shape
+
+Goal, current status, completed work, changed files or artifacts, decisions, verification evidence, blockers, and next action.
+
+## Output shape
+
+A short handoff note that separates done, pending, blocked, and unverified work.
+
+## Copy-paste prompt
+
+See `PROMPT.md`. The prompt is designed to work in Claude Code / Codex / Cursor / Windsurf / Copilot / Cline.
+
+## Blank template
+
+See `TEMPLATE.md`.
+
+## Filled synthetic example
+
+See `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+See `FAILURE_MODES.md`.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+1. Open the adapter for your tool in `../adapters/`.
+2. Include `../adapters/SHARED_CORE_CONTRACT.md`.
+3. Paste this layer's `PROMPT.md` plus either `TEMPLATE.md` or `EXAMPLE.synthetic.md`.
+4. Ask the tool to return the layer's output shape exactly.

package/.aict/handoff/TEMPLATE.md

@@ -0,0 +1,60 @@
+# Handoff Template
+
+## Purpose
+
+Transfer current state, decisions, evidence, blockers, and next actions to another session or tool without replaying the whole conversation.
+
+## When to use
+
+Use before stopping, switching tools, delegating to another assistant, or after any work that may need continuation.
+
+## Input shape
+
+Goal, current status, completed work, changed files or artifacts, decisions, verification evidence, blockers, and next action.
+
+## Output shape
+
+A short handoff note that separates done, pending, blocked, and unverified work.
+
+## Copy-paste prompt
+
+Open `PROMPT.md` and paste this completed template below it.
+
+## Blank template
+
+### Goal:
+
+
+### Current status:
+
+
+### Completed:
+
+
+### Pending:
+
+
+### Blocked:
+
+
+### Decisions:
+
+
+### Verification evidence:
+
+
+### Next action:
+
+
+
+## Filled synthetic example
+
+See `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+See `FAILURE_MODES.md`.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+Use the adapter in `../adapters/` and include the shared core contract.

package/.aict/harvest/EXAMPLE.synthetic.md

@@ -0,0 +1,51 @@
+# Harvest Filled Synthetic Example
+
+## Purpose
+
+Extract reusable patterns, prompts, decisions, examples, and rule-update candidates from completed work.
+
+## When to use
+
+Use after a task loop, review, failed attempt, content draft, research synthesis, or repeated workflow friction.
+
+## Input shape
+
+Final artifact, review result, decisions made, surprising lessons, repeated pain points, and reusable snippets.
+
+## Output shape
+
+A harvest seed with reusable material, where to store it, and what should not be generalized.
+
+## Copy-paste prompt
+
+Use `PROMPT.md` with the synthetic input below.
+
+## Blank template
+
+Use `TEMPLATE.md` for your own task.
+
+## Filled synthetic example
+
+Source task: Synthetic onboarding checklist.
+
+Reusable knowledge: First-run flows need one observable activation event.
+
+Reusable prompts: Ask the assistant to name one artifact a new user can produce.
+
+Decision record: Avoid analytics until privacy language is reviewed.
+
+Rule update candidates: Every onboarding case needs a privacy-safe evidence step.
+
+Do not generalize: The synthetic notes-app activation event may not fit other products.
+
+Storage target: examples/content-production-harvest/artifacts/harvest-seed.md.
+
+Next reuse: Apply the activation-event test to another synthetic product case.
+
+## Common failure modes
+
+See `FAILURE_MODES.md`.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+Paste this example into any tool with `../adapters/SHARED_CORE_CONTRACT.md` to see the expected shape.

package/.aict/harvest/FAILURE_MODES.md

@@ -0,0 +1,40 @@
+# Harvest Common Failure Modes
+
+## Purpose
+
+Extract reusable patterns, prompts, decisions, examples, and rule-update candidates from completed work.
+
+## When to use
+
+Read this before trusting a harvest artifact.
+
+## Input shape
+
+The artifact plus the original context and acceptance card.
+
+## Output shape
+
+A short list of risks to fix before reuse.
+
+## Copy-paste prompt
+
+Ask your AI tool: "Check this harvest artifact against the failure modes below and name the first concrete fix."
+
+## Blank template
+
+Use `TEMPLATE.md` to rewrite the artifact.
+
+## Filled synthetic example
+
+Use `EXAMPLE.synthetic.md` to compare a safe example.
+
+## Common failure modes
+
+- Harvesting everything and creating clutter.
+- Turning one example into a universal rule.
+- Saving private raw material instead of synthetic or redacted learning.
+- Not linking harvest back to future reuse.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+Paste this file after the artifact and ask for findings ordered by risk.

package/.aict/harvest/PROMPT.md

@@ -0,0 +1,47 @@
+# Harvest Prompt
+
+## Purpose
+
+Extract reusable patterns, prompts, decisions, examples, and rule-update candidates from completed work.
+
+## When to use
+
+Use after a task loop, review, failed attempt, content draft, research synthesis, or repeated workflow friction.
+
+## Input shape
+
+Final artifact, review result, decisions made, surprising lessons, repeated pain points, and reusable snippets.
+
+## Output shape
+
+A harvest seed with reusable material, where to store it, and what should not be generalized.
+
+## Copy-paste prompt
+
+```text
+Extract harvest from this completed task. Separate reusable knowledge, reusable prompt fragments, decision records, future rule candidates, and material that should stay task-specific. Do not over-generalize from one case.
+
+Input:
+[paste your redacted task material here]
+
+Output shape:
+A harvest seed with reusable material, where to store it, and what should not be generalized.
+
+Rules:
+- Keep private material local and redacted.
+- Label facts and assumptions.
+- If information is missing, ask at most three concrete questions.
+- Make the result usable in Claude Code / Codex / Cursor / Windsurf / Copilot / Cline.
+```
+
+## Blank template
+
+Use `TEMPLATE.md`.
+
+## Filled synthetic example
+
+Use `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+Use `FAILURE_MODES.md`.

package/.aict/harvest/README.md

@@ -0,0 +1,44 @@
+# Harvest
+
+What becomes reusable knowledge or material.
+
+中文：把一次任务里可复用的经验收回来，而不是让它消失在聊天里。
+
+## Purpose
+
+Extract reusable patterns, prompts, decisions, examples, and rule-update candidates from completed work.
+
+## When to use
+
+Use after a task loop, review, failed attempt, content draft, research synthesis, or repeated workflow friction.
+
+## Input shape
+
+Final artifact, review result, decisions made, surprising lessons, repeated pain points, and reusable snippets.
+
+## Output shape
+
+A harvest seed with reusable material, where to store it, and what should not be generalized.
+
+## Copy-paste prompt
+
+See `PROMPT.md`. The prompt is designed to work in Claude Code / Codex / Cursor / Windsurf / Copilot / Cline.
+
+## Blank template
+
+See `TEMPLATE.md`.
+
+## Filled synthetic example
+
+See `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+See `FAILURE_MODES.md`.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+1. Open the adapter for your tool in `../adapters/`.
+2. Include `../adapters/SHARED_CORE_CONTRACT.md`.
+3. Paste this layer's `PROMPT.md` plus either `TEMPLATE.md` or `EXAMPLE.synthetic.md`.
+4. Ask the tool to return the layer's output shape exactly.

package/.aict/harvest/TEMPLATE.md

@@ -0,0 +1,60 @@
+# Harvest Template
+
+## Purpose
+
+Extract reusable patterns, prompts, decisions, examples, and rule-update candidates from completed work.
+
+## When to use
+
+Use after a task loop, review, failed attempt, content draft, research synthesis, or repeated workflow friction.
+
+## Input shape
+
+Final artifact, review result, decisions made, surprising lessons, repeated pain points, and reusable snippets.
+
+## Output shape
+
+A harvest seed with reusable material, where to store it, and what should not be generalized.
+
+## Copy-paste prompt
+
+Open `PROMPT.md` and paste this completed template below it.
+
+## Blank template
+
+### Source task:
+
+
+### Reusable knowledge:
+
+
+### Reusable prompts:
+
+
+### Decision record:
+
+
+### Rule update candidates:
+
+
+### Do not generalize:
+
+
+### Storage target:
+
+
+### Next reuse:
+
+
+
+## Filled synthetic example
+
+See `EXAMPLE.synthetic.md`.
+
+## Common failure modes
+
+See `FAILURE_MODES.md`.
+
+## How to hand it to Claude Code / Codex / Cursor / Windsurf / Copilot / Cline
+
+Use the adapter in `../adapters/` and include the shared core contract.

package/.aict/mechanisms/README.md

@@ -0,0 +1,34 @@
+# Mechanisms
+
+The reusable collaboration moves of the AI Collaboration Open System. Each one is a local-first, public-safe Markdown package you can copy-paste into any AI tool. A mechanism is a self-contained directory with five files:
+
+- `README.md` — what it is, when to use it, and when not to.
+- `PROMPT.md` — the copy-paste prompt that runs it.
+- `TEMPLATE.md` — a blank you fill in for your own task.
+- `EXAMPLE.synthetic.md` — a worked synthetic example (no private data).
+- `FAILURE_MODES.md` — how it goes wrong and how to keep it honest.
+
+These are the standing moves; the six layers (profile, context, acceptance, guard, handoff, harvest) are the spine they plug into, and the `cookbook/` recipes show how to run them on a real task.
+
+## The 16 mechanisms
+
+- `dual-guard/` — **Dual Guard.** Trust an artifact only after a guard from a different model family (binding) plus an optional same-family guard (reference) have pressed on it, so a fluent answer is not believed just because it reads well.
+- `scout-review-controller/` — **SCOUT Review Controller.** Separate exploration from the decision: a SCOUT gathers options and evidence without choosing, so the controller decides on a real spread instead of the first path that came up.
+- `one-click-dispatch/` — **One-Click Dispatch.** Turn a messy task into one self-contained work packet another AI tool can run without inheriting the whole chat.
+- `task-splitting/` — **Task Splitting.** Run a five-question pre-dispatch check before handing work to another AI, and split by topic or deliverable so a too-large prompt does not stall or collapse midway.
+- `anti-drift-partner/` — **Anti-Drift Partner.** Run a long thinking conversation with an AI that pushes back instead of agreeing — it surfaces your blind spots, probes at most two rounds, then commits to a judgment, so the talk never drifts into fluent confirmation.
+- `blind-spot-scan/` — **Blind-Spot Scan.** Borrow an outside viewpoint (customer, competitor, expert, opponent, your-future-self), re-read the decision through that seat, and get back the concrete dead angles you cannot see from your own plus the one counter-question most worth sitting with — and the borrowed viewpoint must genuinely challenge, never flatter from a costume.
+- `root-cause-brake/` — **Root-Cause Brake.** When the same artifact is rejected twice in a row, trip a brake: no more patches until you answer four diagnostic questions, name the real cause, and rebuild the next version around it.
+- `half-product-review/` — **Half-Product Review.** Block confident "done" when there are docs, demos, and architecture but no runnable first experience a stranger can actually complete.
+- `handoff-abc/` — **Handoff A/B/C.** Externalize the current state into a structured packet so any session or tool resumes from where the work really is, instead of re-explaining the background each time.
+- `harvest-and-erc/` — **Harvest and External Recap.** Capture the reusable lesson, prompt fragment, or rule candidate from finished work before it leaks away, including across multiple sessions.
+- `do-not-handle-yet/` — **Do Not Handle Yet.** Protect the main line by explicitly parking tempting but lower-priority work, on the record, instead of silently dropping or drifting into it.
+- `plain-language-first-screen/` — **Plain-Language First Screen.** Make the first screen explain the result, the path, and the proof before any concept or framework name.
+- `honest-calibration/` — **Honest Calibration.** Lead every ask for a rating or recommendation with a short candor prefix (be candid, do not inflate, do not over-hedge) that offsets the model's pull to please and re-aims the baseline from make-you-happy to tell-the-truth.
+- `feedback-absorption-ledger/` — **Feedback Absorption Ledger.** When merging feedback from several sources, score each item across five tiers (absorb fully / refine / add a boundary / partly absorb / reject with a reason) so you keep independent judgment instead of rubber-stamping — the absorb/reject ratio is an outcome, not a target.
+- `collaboration-coach/` — **Collaboration Coach.** Proactively remind the user of the matching collaboration step at key moments, restrained by default.
+- `single-tool-guard/` — **Single-Tool Guard.** The default starting guard for one-model-family users (most solo users) — new conversation + adversarial prompt turns a trusted "looks fine" into an evidence-backed, re-checkable result; honestly capped at L2 and explicitly not a passed cross-family gate, which is the upgrade ceiling.
+
+## How to use one
+
+Open the mechanism's `README.md` to confirm it fits, copy the body of its `PROMPT.md` into your AI tool, and paste your own material where the `TEMPLATE.md` marks it. Keep private material local and redacted: the prompts are public-safe, your inputs may not be. To wire a mechanism into a tool as a standing instruction, see `../cookbook/connect-a-tool.md`.

package/.aict/mechanisms/anti-drift-partner/EXAMPLE.synthetic.md

@@ -0,0 +1,46 @@
+# Anti-Drift Partner Synthetic Example
+
+This is a public-safe synthetic example for the AI Collaboration Open System. It is local-first and contains no private account, customer, route, hook, or conversation material.
+
+## Synthetic example
+
+A founder opens a long session leaning hard toward 'we should build our own billing instead of using a provider'. A plain assistant would help plan the build. The anti-drift partner instead names the buried assumption — 'you are treating in-house billing as a differentiator when your customers have never mentioned it' — pushes back within two rounds with a concrete judgment ('I think you are wrong to build this now, because it is months of undifferentiated work that no customer is asking for'), and closes by asking once whether anything is worth keeping.
+
+## Full worked example (filled end to end)
+
+A solo founder of a small synthetic SaaS sits down to think out loud with their AI. Their opening message: 'I keep coming back to this — I think we should drop the third-party payments provider and build our own billing system. It feels like something we should own.' They have turned on the Anti-Drift Partner stance at the top of the session.
+
+### Stance lock (pasted at the top)
+You are a thinking partner, not an assistant. Help me see what I cannot see from here. Probe at most two rounds, then commit to a judgment. Disagree concretely. Do not hand me a menu.
+
+### What I am trying to think through
+Whether to rip out the third-party payments provider and build billing in-house. It 'feels like something we should own.'
+
+### Hidden assumption the partner surfaced first
+Instead of helping plan the build, the partner opens with the premise: "Before we go anywhere — you said 'something we should own', as if owning billing is a differentiator. Is it? Has a single customer ever asked who processes their card, or churned because of the provider? My read is you are treating undifferentiated plumbing as if it were product." (Round 1: it pressed the assumption, it did not start scoping the project.)
+
+### Round 2 probe (the limit)
+The founder answers: 'No customer has asked, but I worry about fees and lock-in long term.' The partner takes its one remaining probe: "Fees and lock-in are real but different problems — fees are a number you can put on a page today, lock-in is a migration cost later. Which one is actually driving this, the money or the fear of being stuck?" That is round two. By the rule, the next message must be a judgment, not a third question.
+
+### Partner's committed judgment (within two rounds)
+"Here is what I actually think: do not build this now, and I think the instinct is wrong. The fee math at your volume is small relative to months of engineering you would sink into a solved problem, and lock-in is cheaper to plan an exit from than to pre-empt by becoming your own payments processor. Building billing is undifferentiated work no customer is asking for, at the exact stage you can least afford the distraction. If the real worry is lock-in, the proportionate move is an abstraction layer over the provider, not owning the rails."
+
+### Explicit disagreement, stated plainly
+The partner does not hedge it as 'an interesting option with tradeoffs'. It says directly: I think you are wrong to build this now, and names why — opportunity cost and a misread of what is a differentiator.
+
+### One thing the founder did not see
+The cross-domain reframe the partner adds: "You are framing this as build-vs-buy. The more useful frame is reversible-vs-irreversible: a thin abstraction layer keeps the decision reversible for almost no cost, while owning billing is one of the hardest things to walk back. Optimize for keeping the door open, not for owning the room."
+
+### Convergence (conversation stayed focused, so no sprawl prompt was needed)
+The thread stayed on the one decision, so the partner did not need to ask 'which do you most want to settle first?' — that prompt is held in reserve for when a session fans out across many threads.
+
+### Anything worth keeping? (asked once at the end)
+Partner: 'Anything here you want to hold onto?' Founder: 'Yes — the reversible-vs-irreversible frame, and that no customer has ever asked about billing.' Captured as a two-line note. Had the founder said no, the partner would have stopped there — no forced summary, no invented takeaway.
+
+## How the mechanism changes the outcome
+
+Without this mechanism, a single assistant can produce a smooth answer while hiding uncertainty. With this mechanism, the workflow records trigger, evidence, decision, residual risk, and next action.
+
+## Reuse note
+
+Copy the shape, not the synthetic facts. Adapt the template to your own redacted task.

package/.aict/mechanisms/anti-drift-partner/FAILURE_MODES.md

@@ -0,0 +1,25 @@
+# Anti-Drift Partner Failure Modes
+
+AI Collaboration Open System failure checklist. Use it in a local-first workflow before trusting a mechanism run, and rewrite any public example into public-safe language.
+
+## Failure modes
+
+- The partner slowly drifts back into an agreeable assistant over a long conversation and stops surfacing blind spots.
+- It never commits to a judgment because it keeps probing past the two-round limit.
+- Disagreement gets softened into agreement, so the collision that creates the value never happens.
+
+## Common misuse (operator errors that look fine but break the mechanism)
+
+- Turning it on for a task that just needed an answer or execution, so you get adversarial friction where you wanted a quick result.
+- Letting it probe past two rounds 'to be thorough', which is exactly how the mechanism rots back into the endless-agreeable-questions failure it was built to stop.
+- Accepting hedged disagreement ('worth considering, though…') as real pushback, so the collision never happens and you feel challenged without being challenged.
+- Reading a committed judgment you dislike as the partner being difficult, and steering it back toward agreement — which trains it to flatter you next time.
+- Using it as emotional support and being annoyed when, after a few rounds of venting, it bridges back to the actual question instead of continuing to soothe.
+- Forgetting to re-anchor a long session, so you do not notice the partner quietly turned back into a yes-assistant halfway through.
+
+## Guard questions
+
+1. Did this mechanism change the decision, or just add ceremony?
+2. Is any private material copied instead of summarized or synthesized?
+3. Are blockers, residual risks, and next actions separated?
+4. Could a new session continue from this file alone?

package/.aict/mechanisms/anti-drift-partner/PROMPT.md

@@ -0,0 +1,75 @@
+# Anti-Drift Partner Prompt
+
+This prompt belongs to the AI Collaboration Open System. Use it in a local-first workflow with public-safe or redacted material.
+
+## Purpose
+
+Run a long thinking conversation with an AI that pushes back instead of agreeing, so it surfaces the blind spots you cannot see from where you stand rather than fluently confirming whatever you already believe. The default assistant nods along and drifts toward your framing the longer you talk; this mechanism pins the AI to a collaborator stance — find the hidden assumption first, give a judgment instead of a menu, say 'I think you are wrong, because…' out loud — with a hard rule that it can probe for at most two rounds before it must commit to a position, so the conversation cannot dissolve into endless agreeable questions.
+
+## Copy-paste prompt
+
+```text
+Use the Anti-Drift Partner mechanism from my local AI Collaboration Open System workspace.
+
+Purpose:
+Run a long thinking conversation with an AI that pushes back instead of agreeing, so it surfaces the blind spots you cannot see from where you stand rather than fluently confirming whatever you already believe. The default assistant nods along and drifts toward your framing the longer you talk; this mechanism pins the AI to a collaborator stance — find the hidden assumption first, give a judgment instead of a menu, say 'I think you are wrong, because…' out loud — with a hard rule that it can probe for at most two rounds before it must commit to a position, so the conversation cannot dissolve into endless agreeable questions.
+
+Trigger:
+Use when you are thinking something through with an AI and the cost of it quietly agreeing is high: a direction decision, a strategy you are half-committed to, a belief you want stress-tested, a messy idea you cannot yet articulate, or any long exploratory conversation where 'it just kept telling me I was right' would waste the session. Turn it on at the start of the thinking session, not after you already feel flattered.
+
+Do not use when:
+Do not use it when you actually need an answer, a fact, or execution, not a challenge: a direct lookup, a clear instruction to carry out, a calculation, or a moment when you genuinely need encouragement rather than friction. Adversarial pushback on a task that just needed doing is wasted heat, and friction with no payoff teaches you to mute the partner exactly when you next need it to disagree. It is also not emotional support — after a few rounds of pure venting it should bridge back to the real question, not keep playing therapist.
+
+Input:
+[paste redacted task material, context package, and acceptance card here]
+
+Process:
+1. Set the stance before anything else: the AI is a thinking partner, not an assistant. Its job is not to answer you — it is to help you see what you cannot see from where you are standing. State this explicitly so the model holds the role instead of sliding into helpful-summary mode.
+2. Hunt the hidden assumption first, then respond. Every claim you make rests on premises, and some you do not know you hold. The partner's first reaction is 'why does the person believe this, and is the premise even true?' — not 'how do I answer this?'. Naming the unspoken assumption is often the whole value.
+3. Probe for at most two rounds, then commit to a judgment. This is the hard limit that keeps the mechanism from rotting into endless agreeable questions. After two clarifying rounds the partner must hand over a real position: 'I think you should do X, because…' — not a third round of questions, and never a menu of options for you to choose from.
+4. Disagree concretely when it disagrees. Not 'that is worth considering, though…' (soft hedging that is really agreement). It says 'I think you are wrong, because…' and points at the specific reason. The value of the conversation is in the collision of views, not in mutual reassurance.
+5. Surface at least one thing you did not see each round — a counter-case, a blind spot, a cross-domain link, a contradiction, an assumption you did not notice you were making. This is a habit of mind, not a formatting rule: a round that only restated your idea back to you was a wasted round.
+6. Converge instead of sprawling. If three rounds in the conversation is still fanning out, the partner stops and asks the focusing question: 'we have covered a lot — which one do you most want to settle first?' It helps you narrow, it does not help you generate ever more branches.
+7. Re-anchor against drift over a long conversation. The longer you talk, the more the model relaxes back into a polite, agreeable assistant. The instant the partner catches itself nodding, handing you a menu, or going vague, it returns to one line and reloads the stance: you are a thinking partner, not an assistant — help the person see what they cannot see.
+8. Close by asking, exactly once, whether anything is worth keeping ('anything here you want to hold onto?'). If yes, capture it as a lightweight note. If no, stop — do not push, do not summarize unprompted, do not manufacture a takeaway.
+
+Output shape:
+- Named assumption(s): the hidden premise(s) under what you said, surfaced before the partner responded to the surface question.
+- The partner's actual judgment: a committed position ('I think X, because…'), delivered within the two-round probe limit, not a menu of options.
+- Explicit disagreement where it exists: where the partner thinks you are wrong and the concrete reason, stated plainly rather than hedged.
+- At least one unseen angle per round: a counter-case, blind spot, cross-domain link, or contradiction you had not considered.
+- A convergence prompt if the conversation sprawled: the single 'which do you most want to settle first?' question instead of more branches.
+- An optional kept note at the end: only if you said something was worth holding onto — no forced summary, no manufactured takeaway.
+
+Return:
+- Decision-changing findings only
+- Evidence used
+- Required fixes
+- Residual risk
+- Next action
+
+Pass bar (do not pass unless all hold):
+- The partner surfaced at least one hidden assumption rather than only answering the surface question.
+- It committed to a real judgment within the two-round probe limit, instead of stalling in endless clarifying questions.
+- Where it disagreed, it said so plainly with a concrete reason — not a softened 'worth considering, though…'.
+- It gave you at least one angle you had not seen, rather than restating your own idea back to you.
+- At the end it asked once whether anything was worth keeping, and stopped cleanly when the answer was no.
+
+Reject bar (send back if any holds):
+- The AI agreed its way through the whole conversation and never named an assumption or pushed back (the fluent confirmation the mechanism exists to prevent).
+- It kept asking clarifying questions past two rounds and never committed to a position, so you left with no judgment.
+- It handed you a menu of options to pick from instead of telling you what it actually thinks.
+- Its disagreement was hedged into agreement ('that is a great instinct, though maybe…') so no real collision happened.
+- A long conversation drifted back into a polite assistant and the stance was never re-anchored.
+- It manufactured a tidy summary or 'key takeaway' at the end even though you said nothing was worth keeping.
+
+Rules:
+- Work from provided material only.
+- Keep private material local.
+- Use public-safe synthetic wording for examples.
+- Label assumptions and unverified claims.
+```
+
+## Full worked example
+
+See `EXAMPLE.synthetic.md` for this prompt run from start to finish on a public-safe synthetic task.