ai-collab-open-system 0.1.0

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

@@ -0,0 +1,82 @@
+# Anti-Drift Partner
+
+Part of the AI Collaboration Open System. This is a local-first, public-safe mechanism package you can copy into Claude Code, Codex, Cursor, Cline, Windsurf, or Copilot.
+
+## 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.
+
+## When to use
+
+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.
+
+## When not to use
+
+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 shape
+
+What you are actually trying to think through, in your own words, even if it is still messy or half-formed (you do NOT need to arrive with a clean question). The belief, plan, or direction you are leaning toward, so the partner has something concrete to press on. Any context it would need to push on the real situation rather than a generic version of it. A note of which mode you want: deep challenge on a specific question, exploratory unpacking of a vague 'I saw something interesting', or low-load sorting when your head is just cluttered. Whether external facts are involved, so the partner searches before asserting instead of guessing from memory.
+
+## Input materials
+
+- The real subject, in your own messy words — a clear question is welcome but not required; a tangle of half-thoughts is a valid input the partner is supposed to mine.
+- The position you are leaning toward (the plan, the belief, the direction), so the partner has a concrete target to disagree with rather than thin air.
+- Enough situational context that the pushback lands on your actual case, not a textbook version of it.
+- The mode you want: deep challenge (specific question), exploratory (unpack a vague spark), or low-load sorting (declutter a noisy head, then bridge to the real question).
+- Whether real-world facts are in play, so the partner searches first and presses on evidence instead of asserting from memory.
+- Your own sense of how committed you already are, so the partner knows whether it is testing a fresh idea or trying to dislodge a belief you have already half-decided.
+
+## 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.
+
+## Pass bar (what counts as done / safe to trust)
+
+- 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 (what sends it back)
+
+- 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.
+
+## Common misuse
+
+- 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.
+
+## Package files
+
+- `README.md` explains the mechanism.
+- `PROMPT.md` gives the copy-paste prompt.
+- `TEMPLATE.md` gives the blank operating card.
+- `EXAMPLE.synthetic.md` shows a public-safe run.
+- `FAILURE_MODES.md` names common ways this mechanism fails.

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

@@ -0,0 +1,74 @@
+# Anti-Drift Partner Template
+
+AI Collaboration Open System mechanism card. Fill this 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.
+
+## Template
+
+### Stance lock (paste 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 actually trying to think through (messy is fine):
+
+
+### What I am currently leaning toward (the position to press on):
+
+
+### Context the pushback needs to land on my real case:
+
+
+### Mode (deep challenge / exploratory unpack / low-load sorting):
+
+
+### External facts involved? (if yes, search before asserting):
+
+
+### Hidden assumption(s) the partner surfaced first:
+
+
+### Partner's committed judgment (within two probe rounds; 'I think X, because…'):
+
+
+### Where the partner says I am wrong, and why (concrete, not hedged):
+
+
+### At least one thing I did not see this round:
+
+
+### Convergence question if we sprawled ('which do you most want to settle first?'):
+
+
+### Anything worth keeping? (asked once at the end; capture only if yes):
+
+
+
+## Pass bar (tick before you trust the result)
+
+- 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 it back if any of these is true)
+
+- 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.
+
+## Worked example
+
+See `EXAMPLE.synthetic.md` for this same card filled out end to end on a public-safe synthetic task.
+
+## Completion check
+
+- The mechanism has a named trigger.
+- The next action is concrete.
+- Private details are redacted or rewritten as synthetic examples.
+- The result can be handed to another AI tool without extra chat history.

package/.aict/mechanisms/blind-spot-scan/EXAMPLE.synthetic.md

@@ -0,0 +1,39 @@
+# Blind-Spot Scan 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 is about to finalize a plan to launch a self-serve plan tier and feels the decision is obvious. A plain assistant would help polish the launch checklist. Blind-Spot Scan instead borrows the customer's seat and reports what the founder cannot see from inside: 'From a customer landing cold on this page — there is no way to talk to a human before paying, and for a tool that now touches my billing data, the absence of any contact or trust signal reads as risky, not frictionless. You are optimizing for fewer clicks; I am hesitating over who I am trusting.' The one counter-question, asked from that seat: 'Before I type my card in, what on this page tells me you will still be here in a year?'
+
+## Full worked example (filled end to end)
+
+A solo founder of a small synthetic SaaS is finalizing a decision and asks for a blind-spot scan. Their message: 'I'm ready to ship a self-serve paid tier — drop the sales call, let people sign up and pay on the page. It feels obviously right, fewer steps, less friction. Scan my blind spots before I commit. You pick the viewpoint.'
+
+### What I want scanned
+Whether to drop the human sales call and ship a fully self-serve paid signup. The founder's leaning: 'obviously right — fewer steps, less friction.'
+
+### Viewpoint taken, and why it fits
+Borrowed seat: the prospective CUSTOMER landing cold on the signup page. For a pricing / conversion decision the customer's line of sight is where the dead angle hides, because the founder is reasoning from inside the funnel (steps to remove) while the customer reasons from outside it (whether to trust this at all). Not the founder wearing a 'customer' label — actually reading the page as someone who has never heard the internal rationale.
+
+### Concrete blind spots this viewpoint sees that the founder did not
+- From the customer's seat: 'The product now wants my card and touches my billing data, but there is no way to reach a human before I pay. For an early tool, no contact path does not read as frictionless — it reads as risky. Who do I email when it breaks?' The founder sees the sales call as a step to delete; the customer sees it as the only trust signal, and deleting it removes the reassurance, not just the friction.
+- 'There is no annual option and no sense of whether this company will still exist in a year. I am being asked to commit billing to a tool that looks like it might vanish.' Invisible from the founder's seat because the founder KNOWS they will still be here; the customer has no way to know that.
+- 'The self-serve flow assumes I already understand what I am buying. The sales call was also where someone would have told me which plan I actually need — without it, I will probably pick wrong, get frustrated, and churn, and you will read that as "self-serve works" because I did sign up.'
+
+### Why each is invisible from where the founder stands
+The founder is optimizing the funnel from the inside, counting clicks to remove. Every one of these blind spots lives on the OUTSIDE of the funnel — trust, longevity, plan-fit — which is exactly the line of sight the founder cannot occupy while standing in the builder's seat. That is why borrowing the seat surfaces them and self-critique would not.
+
+### Honesty check
+The viewpoint genuinely challenged — it did NOT say 'as a customer I'd love the smooth signup'. The convenient, flattering version (a customer delighted by fewer clicks) was specifically refused; the borrowed seat surfaced what the customer would actually hesitate over, which is the whole point. This is the failure the mechanism most guards against, so it is checked explicitly here.
+
+### The one counter-question most worth sitting with
+Asked from the customer's seat: 'Before I type my card into this page, what here tells me you will still be around in a year and that I can reach a human when it breaks?' If the founder cannot answer that from the page as it stands, the 'obviously right' self-serve plan is shipping a trust gap, not just removing friction — and that is the thing to settle before committing.
+
+## 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/blind-spot-scan/FAILURE_MODES.md

@@ -0,0 +1,25 @@
+# Blind-Spot Scan 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 borrowed viewpoint quietly turns into a flattering yes-voice that approves the plan, so the scan produces false comfort instead of a real blind spot.
+- The observations stay generic and unfalsifiable ('there could be risks you haven't considered') rather than naming a specific dead angle tied to the situation.
+- The wrong viewpoint is chosen for the topic, so the outside seat has no real line of sight and the scan surfaces nothing the author could not already see.
+
+## Common misuse (operator errors that look fine but break the mechanism)
+
+- Running it as a rubber stamp — picking a viewpoint that is set up to approve, so you feel challenged without being challenged and walk away more confident than you earned.
+- Letting the borrowed viewpoint flatter ('as a customer, I'd love this!') instead of forcing it to say what that customer would actually dislike, distrust, or ignore.
+- Choosing a viewpoint that has no real line of sight on the decision, so the scan produces plausible-sounding but empty observations.
+- Confusing it with the anti-drift partner and using it to pressure-test your own internal reasoning, when its specific job is to borrow someone else's eyes.
+- Padding the output with five viewpoints and twenty generic worries for the appearance of thoroughness, burying the one or two real blind spots in noise.
+- Skipping it on exactly the high-stakes, already-decided call where the dead angle is most likely to be hiding, because the decision 'feels obvious'.
+
+## 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/blind-spot-scan/PROMPT.md

@@ -0,0 +1,72 @@
+# Blind-Spot Scan Prompt
+
+This prompt belongs to the AI Collaboration Open System. Use it in a local-first workflow with public-safe or redacted material.
+
+## Purpose
+
+Surface the dead angles you cannot see from your own seat by borrowing an outside viewpoint and re-reading the discussion through it, instead of stress-testing your own logic from the inside. Your own position has a fixed line of sight: the assumptions that feel obvious, the stakeholders you have stopped picturing, the failure that is invisible precisely because it sits where you are standing. This mechanism deliberately swaps the eyes — a customer, a competitor, a domain expert, an opponent, the version of you three years out — and asks what THAT viewpoint would notice that you did not, then hands back a short list of concrete blind spots plus the one counter-question most worth sitting with.
+
+## Copy-paste prompt
+
+```text
+Use the Blind-Spot Scan mechanism from my local AI Collaboration Open System workspace.
+
+Purpose:
+Surface the dead angles you cannot see from your own seat by borrowing an outside viewpoint and re-reading the discussion through it, instead of stress-testing your own logic from the inside. Your own position has a fixed line of sight: the assumptions that feel obvious, the stakeholders you have stopped picturing, the failure that is invisible precisely because it sits where you are standing. This mechanism deliberately swaps the eyes — a customer, a competitor, a domain expert, an opponent, the version of you three years out — and asks what THAT viewpoint would notice that you did not, then hands back a short list of concrete blind spots plus the one counter-question most worth sitting with.
+
+Trigger:
+Use it when you ask for it by name — 'scan my blind spots', 'blind spots', 'look at this from outside', 'switch the viewpoint' — or, even unprompted, right before a high-stakes or hard-to-reverse decision and when you are finalizing a plan and want a fresh angle before you commit. It is most valuable exactly when you feel most settled: a direction you have already half-decided, a plan that looks complete, a conclusion everyone in the room nodded at. The more obvious your view feels, the more a borrowed viewpoint is likely to catch something the consensus is sitting on top of.
+
+Do not use when:
+Skip it when there is no real exposure to a blind spot: a quick fact lookup, a one-line edit, a mechanical step with a single obvious answer, or a reversible call where being wrong costs almost nothing. Forcing an outside-viewpoint scan onto a trivial task is ceremony, and a viewpoint switch you run on everything trains you to wave it off on the one high-stakes decision where the dead angle actually hides. It is also not a general critique tool: if you want your own reasoning pressure-tested from the inside, that is the anti-drift partner; this mechanism specifically borrows someone else's eyes.
+
+Input:
+[paste redacted task material, context package, and acceptance card here]
+
+Process:
+1. Pick the outside viewpoint before reading anything else. If the user named one, take it; if not, auto-pick the angle most likely to expose a dead spot for THIS topic — a customer for a product or pricing call, a competitor for a strategy or positioning call, a domain expert for a technical or risk call, an opponent for an argument you are building, your-future-self for an irreversible commitment. State which viewpoint you took and why it fits, so the borrowing is explicit, not a vague 'devil's advocate'.
+2. Re-read the entire discussion THROUGH that viewpoint, not through your own. This is the whole mechanism: do not evaluate the plan as yourself wearing a label — actually reason from the other seat. What does a customer who has never heard your internal rationale see first? What does a competitor hope you keep believing? What does the expert know is a solved-and-painful problem that you are treating as novel? Inhabit the line of sight, then look back at the decision from there.
+3. Name what that viewpoint sees that you did not — concretely, not in the abstract. Not 'a customer might have concerns' but 'a customer lands on the pricing page, sees no annual option, and assumes the product is too early to commit to'. Each blind spot should be a specific thing visible from the borrowed seat and invisible from yours, tied to the actual situation.
+4. Keep it honest pushback, never a costume that agrees. The single worst failure of this mechanism is a FAKE outside-view: a 'customer' who conveniently loves everything, a 'competitor' who is politely impressed, an 'expert' who validates your plan. A borrowed viewpoint that flatters is theater — it must genuinely challenge from that seat, surfacing what that person would actually find wrong, uncomfortable, or naive, even when it stings. If the viewpoint cannot find anything, say so plainly rather than manufacturing soft praise.
+5. Stay concrete and bounded, not a vague fog of 'have you considered everything'. A short list of real, specific blind spots beats a long list of generic worries; if the borrowed viewpoint genuinely surfaces only two things, give two. Vagueness is the second-worst failure here, because 'you might be missing something' is unfalsifiable and changes nothing.
+6. End with the ONE counter-question most worth thinking about — the single question, asked from the borrowed viewpoint, that would most change the decision if you sat with it honestly. Not a list of questions; the one that has the most leverage.
+
+Output shape:
+- Viewpoint borrowed: which outside seat was taken (customer / competitor / expert / opponent / you-in-3-years) and one line on why it fits this topic.
+- Concrete blind spots: a short list of specific things that viewpoint sees and you did not, each tied to the actual situation rather than phrased as a generic concern.
+- Why each is invisible from your seat: the one-line reason the dead angle sits exactly where you are standing, so it reads as a real blind spot and not just a critique.
+- Honesty check: an explicit signal that the borrowed viewpoint genuinely challenged (or, if it truly found little, a plain statement of that) — never a flattering costume that secretly agrees.
+- The one counter-question: the single highest-leverage question, asked from the borrowed viewpoint, most worth sitting with before you commit.
+- Optional second angle: only if a different viewpoint would expose something the first could not, named briefly — not padded with extra viewpoints for volume.
+
+Return:
+- Decision-changing findings only
+- Evidence used
+- Required fixes
+- Residual risk
+- Next action
+
+Pass bar (do not pass unless all hold):
+- An explicit outside viewpoint was named and the scan actually reasoned FROM that seat, not as the author wearing a label.
+- The blind spots are concrete and tied to the real situation, not a generic 'you might be missing something' fog.
+- The borrowed viewpoint genuinely challenged — it surfaced what that person would really find wrong or naive, rather than flattering the plan from a costume.
+- Each blind spot reads as something invisible from the author's own seat, with a one-line reason it hides there.
+- It ends with exactly one high-leverage counter-question, not a scattershot list.
+
+Reject bar (send back if any holds):
+- The outside viewpoint secretly agrees — a 'customer' who loves everything, a 'competitor' who is impressed, an 'expert' who validates the plan: the fake outside-view that is the mechanism's worst failure.
+- The viewpoint chosen is irrelevant to the topic (a generic bystander for a deep technical call), so the borrowed eyes see nothing the author could not.
+- The blind spots stay vague and unfalsifiable ('have you considered all the risks?') instead of pointing at a specific, situation-tied dead angle.
+- The scan is really the author critiquing their own logic with a label slapped on, never actually inhabiting the other line of sight.
+- It sprawls into a long list of generic worries or many half-used viewpoints instead of a short concrete set plus the single counter-question that matters.
+
+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.

package/.aict/mechanisms/blind-spot-scan/README.md

@@ -0,0 +1,79 @@
+# Blind-Spot Scan
+
+Part of the AI Collaboration Open System. This is a local-first, public-safe mechanism package you can copy into Claude Code, Codex, Cursor, Cline, Windsurf, or Copilot.
+
+## Purpose
+
+Surface the dead angles you cannot see from your own seat by borrowing an outside viewpoint and re-reading the discussion through it, instead of stress-testing your own logic from the inside. Your own position has a fixed line of sight: the assumptions that feel obvious, the stakeholders you have stopped picturing, the failure that is invisible precisely because it sits where you are standing. This mechanism deliberately swaps the eyes — a customer, a competitor, a domain expert, an opponent, the version of you three years out — and asks what THAT viewpoint would notice that you did not, then hands back a short list of concrete blind spots plus the one counter-question most worth sitting with.
+
+## When to use
+
+Use it when you ask for it by name — 'scan my blind spots', 'blind spots', 'look at this from outside', 'switch the viewpoint' — or, even unprompted, right before a high-stakes or hard-to-reverse decision and when you are finalizing a plan and want a fresh angle before you commit. It is most valuable exactly when you feel most settled: a direction you have already half-decided, a plan that looks complete, a conclusion everyone in the room nodded at. The more obvious your view feels, the more a borrowed viewpoint is likely to catch something the consensus is sitting on top of.
+
+## When not to use
+
+Skip it when there is no real exposure to a blind spot: a quick fact lookup, a one-line edit, a mechanical step with a single obvious answer, or a reversible call where being wrong costs almost nothing. Forcing an outside-viewpoint scan onto a trivial task is ceremony, and a viewpoint switch you run on everything trains you to wave it off on the one high-stakes decision where the dead angle actually hides. It is also not a general critique tool: if you want your own reasoning pressure-tested from the inside, that is the anti-drift partner; this mechanism specifically borrows someone else's eyes.
+
+## Input shape
+
+The decision, plan, or belief you want scanned, in enough concrete detail that an outside viewpoint can land on YOUR actual situation rather than a generic version of it. The viewpoint you want borrowed, if you have one in mind (customer, competitor, expert, opponent, your-future-self) — and if you do not name one, leave it to the mechanism to auto-pick the angle most likely to expose something for this specific topic. What is actually at stake, so the scan can prioritize the blind spots that would hurt. Any context the outside viewpoint would need to see the situation the way that person really would. Whether real-world facts are involved, so the viewpoint reasons from evidence rather than a caricature of how a customer or competitor 'probably' thinks.
+
+## Input materials
+
+- The decision / plan / belief under scan, concrete enough that the borrowed viewpoint reacts to your real case, not a textbook stand-in.
+- The viewpoint to borrow, if you have a preference (customer / competitor / expert / opponent / you-in-3-years); otherwise an explicit 'you pick the most fitting angle' so the mechanism chooses by topic.
+- What is at stake and what a wrong call would cost, so the scan surfaces the blind spots that matter instead of cosmetic ones.
+- Enough situational context that the outside viewpoint sees the situation as that person actually would, including the parts you find inconvenient.
+- Whether external facts are in play, so the viewpoint reasons from real evidence rather than a flattering or strawman guess about how that party thinks.
+- Your current conclusion or leaning, named openly, so the scan can check it against the borrowed eyes rather than quietly reinforcing it.
+
+## Process
+
+1. Pick the outside viewpoint before reading anything else. If the user named one, take it; if not, auto-pick the angle most likely to expose a dead spot for THIS topic — a customer for a product or pricing call, a competitor for a strategy or positioning call, a domain expert for a technical or risk call, an opponent for an argument you are building, your-future-self for an irreversible commitment. State which viewpoint you took and why it fits, so the borrowing is explicit, not a vague 'devil's advocate'.
+2. Re-read the entire discussion THROUGH that viewpoint, not through your own. This is the whole mechanism: do not evaluate the plan as yourself wearing a label — actually reason from the other seat. What does a customer who has never heard your internal rationale see first? What does a competitor hope you keep believing? What does the expert know is a solved-and-painful problem that you are treating as novel? Inhabit the line of sight, then look back at the decision from there.
+3. Name what that viewpoint sees that you did not — concretely, not in the abstract. Not 'a customer might have concerns' but 'a customer lands on the pricing page, sees no annual option, and assumes the product is too early to commit to'. Each blind spot should be a specific thing visible from the borrowed seat and invisible from yours, tied to the actual situation.
+4. Keep it honest pushback, never a costume that agrees. The single worst failure of this mechanism is a FAKE outside-view: a 'customer' who conveniently loves everything, a 'competitor' who is politely impressed, an 'expert' who validates your plan. A borrowed viewpoint that flatters is theater — it must genuinely challenge from that seat, surfacing what that person would actually find wrong, uncomfortable, or naive, even when it stings. If the viewpoint cannot find anything, say so plainly rather than manufacturing soft praise.
+5. Stay concrete and bounded, not a vague fog of 'have you considered everything'. A short list of real, specific blind spots beats a long list of generic worries; if the borrowed viewpoint genuinely surfaces only two things, give two. Vagueness is the second-worst failure here, because 'you might be missing something' is unfalsifiable and changes nothing.
+6. End with the ONE counter-question most worth thinking about — the single question, asked from the borrowed viewpoint, that would most change the decision if you sat with it honestly. Not a list of questions; the one that has the most leverage.
+
+## Output shape
+
+- Viewpoint borrowed: which outside seat was taken (customer / competitor / expert / opponent / you-in-3-years) and one line on why it fits this topic.
+- Concrete blind spots: a short list of specific things that viewpoint sees and you did not, each tied to the actual situation rather than phrased as a generic concern.
+- Why each is invisible from your seat: the one-line reason the dead angle sits exactly where you are standing, so it reads as a real blind spot and not just a critique.
+- Honesty check: an explicit signal that the borrowed viewpoint genuinely challenged (or, if it truly found little, a plain statement of that) — never a flattering costume that secretly agrees.
+- The one counter-question: the single highest-leverage question, asked from the borrowed viewpoint, most worth sitting with before you commit.
+- Optional second angle: only if a different viewpoint would expose something the first could not, named briefly — not padded with extra viewpoints for volume.
+
+## Pass bar (what counts as done / safe to trust)
+
+- An explicit outside viewpoint was named and the scan actually reasoned FROM that seat, not as the author wearing a label.
+- The blind spots are concrete and tied to the real situation, not a generic 'you might be missing something' fog.
+- The borrowed viewpoint genuinely challenged — it surfaced what that person would really find wrong or naive, rather than flattering the plan from a costume.
+- Each blind spot reads as something invisible from the author's own seat, with a one-line reason it hides there.
+- It ends with exactly one high-leverage counter-question, not a scattershot list.
+
+## Reject bar (what sends it back)
+
+- The outside viewpoint secretly agrees — a 'customer' who loves everything, a 'competitor' who is impressed, an 'expert' who validates the plan: the fake outside-view that is the mechanism's worst failure.
+- The viewpoint chosen is irrelevant to the topic (a generic bystander for a deep technical call), so the borrowed eyes see nothing the author could not.
+- The blind spots stay vague and unfalsifiable ('have you considered all the risks?') instead of pointing at a specific, situation-tied dead angle.
+- The scan is really the author critiquing their own logic with a label slapped on, never actually inhabiting the other line of sight.
+- It sprawls into a long list of generic worries or many half-used viewpoints instead of a short concrete set plus the single counter-question that matters.
+
+## Common misuse
+
+- Running it as a rubber stamp — picking a viewpoint that is set up to approve, so you feel challenged without being challenged and walk away more confident than you earned.
+- Letting the borrowed viewpoint flatter ('as a customer, I'd love this!') instead of forcing it to say what that customer would actually dislike, distrust, or ignore.
+- Choosing a viewpoint that has no real line of sight on the decision, so the scan produces plausible-sounding but empty observations.
+- Confusing it with the anti-drift partner and using it to pressure-test your own internal reasoning, when its specific job is to borrow someone else's eyes.
+- Padding the output with five viewpoints and twenty generic worries for the appearance of thoroughness, burying the one or two real blind spots in noise.
+- Skipping it on exactly the high-stakes, already-decided call where the dead angle is most likely to be hiding, because the decision 'feels obvious'.
+
+## Package files
+
+- `README.md` explains the mechanism.
+- `PROMPT.md` gives the copy-paste prompt.
+- `TEMPLATE.md` gives the blank operating card.
+- `EXAMPLE.synthetic.md` shows a public-safe run.
+- `FAILURE_MODES.md` names common ways this mechanism fails.

package/.aict/mechanisms/blind-spot-scan/TEMPLATE.md

@@ -0,0 +1,70 @@
+# Blind-Spot Scan Template
+
+AI Collaboration Open System mechanism card. Fill this in a local-first workflow with public-safe or redacted material.
+
+## Purpose
+
+Surface the dead angles you cannot see from your own seat by borrowing an outside viewpoint and re-reading the discussion through it, instead of stress-testing your own logic from the inside. Your own position has a fixed line of sight: the assumptions that feel obvious, the stakeholders you have stopped picturing, the failure that is invisible precisely because it sits where you are standing. This mechanism deliberately swaps the eyes — a customer, a competitor, a domain expert, an opponent, the version of you three years out — and asks what THAT viewpoint would notice that you did not, then hands back a short list of concrete blind spots plus the one counter-question most worth sitting with.
+
+## Template
+
+### What I want scanned (decision / plan / belief, concrete):
+
+
+### Viewpoint to borrow (customer / competitor / expert / opponent / you-in-3-years — or 'you pick the most fitting'):
+
+
+### What is at stake / what a wrong call costs:
+
+
+### Context the outside viewpoint needs to see my real situation:
+
+
+### External facts involved? (if yes, reason from evidence, not a caricature):
+
+
+### My current leaning (named openly so it can be checked, not reinforced):
+
+
+### Viewpoint actually taken, and why it fits this topic:
+
+
+### Concrete blind spots this viewpoint sees that I did not:
+
+
+### Why each is invisible from where I stand:
+
+
+### Honesty check (did the viewpoint genuinely challenge, or did it find little — stated plainly):
+
+
+### The one counter-question most worth sitting with:
+
+
+
+## Pass bar (tick before you trust the result)
+
+- An explicit outside viewpoint was named and the scan actually reasoned FROM that seat, not as the author wearing a label.
+- The blind spots are concrete and tied to the real situation, not a generic 'you might be missing something' fog.
+- The borrowed viewpoint genuinely challenged — it surfaced what that person would really find wrong or naive, rather than flattering the plan from a costume.
+- Each blind spot reads as something invisible from the author's own seat, with a one-line reason it hides there.
+- It ends with exactly one high-leverage counter-question, not a scattershot list.
+
+## Reject bar (send it back if any of these is true)
+
+- The outside viewpoint secretly agrees — a 'customer' who loves everything, a 'competitor' who is impressed, an 'expert' who validates the plan: the fake outside-view that is the mechanism's worst failure.
+- The viewpoint chosen is irrelevant to the topic (a generic bystander for a deep technical call), so the borrowed eyes see nothing the author could not.
+- The blind spots stay vague and unfalsifiable ('have you considered all the risks?') instead of pointing at a specific, situation-tied dead angle.
+- The scan is really the author critiquing their own logic with a label slapped on, never actually inhabiting the other line of sight.
+- It sprawls into a long list of generic worries or many half-used viewpoints instead of a short concrete set plus the single counter-question that matters.
+
+## Worked example
+
+See `EXAMPLE.synthetic.md` for this same card filled out end to end on a public-safe synthetic task.
+
+## Completion check
+
+- The mechanism has a named trigger.
+- The next action is concrete.
+- Private details are redacted or rewritten as synthetic examples.
+- The result can be handed to another AI tool without extra chat history.

package/.aict/mechanisms/collaboration-coach/EXAMPLE.synthetic.md

@@ -0,0 +1,40 @@
+# Collaboration Coach 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 synthetic execution session reaches a 'done, implemented and tested' claim. At the completion-claim node the coach fires once, sees only one model family is available, and points the user to single-tool-guard (new conversation plus an adversarial prompt) instead of accepting the fluent claim — then continues, without lecturing.
+
+## Full worked example (filled end to end)
+
+A solo user is working in one AI tool on a small synthetic feature. The coach runs at standard. The session passes through several collaboration moments; this shows the coach firing at the completion-claim node, once, with a concrete next step.
+
+### First-run: act proactively the first time
+"You just installed a collaboration discipline — before I say 'done' I'll show evidence, when I'm unsure I'll pull in a second AI, you won't re-explain when you switch tools, and I'll help you save what's worth keeping. Want me to take 30 seconds and look at a few of your recent tasks to show you what this changes?" Then it offers a scan, respects yes / narrow / no, and gets to work; it does not repeat this.
+
+### Firing node and signal
+Node 3, completion claim. The execution assistant just returned: "Done. I implemented the new sort option and added a test; everything passes." That 'done / everything passes' phrasing is the signal.
+
+### Restraint tier in effect
+Standard (default). Nodes 1 and 2 already fired once earlier this session (a one-line 'want to set acceptance first?' at task start), so they are not re-raised. Node 3 has not fired yet, so it may fire now — once.
+
+### Matching reminder (one or two sentences, concrete next step)
+"Before trusting that 'done', this is the completion-claim moment — worth a guard review. You're on a single tool right now, so the fitting move is single-tool-guard: open a fresh conversation and paste an adversarial reviewer prompt against this claim. Want the prompt?"
+
+### Completion-claim branch
+Only one model family is available, so the coach named single-tool-guard (new conversation + adversarial prompt), explicitly NOT dual-guard. It noted in passing that if a second, different model family were available, the stronger move would be the cross-family dual-guard, and a multi-tool setup would run the full fusion review.
+
+### Tier change to acknowledge
+None this turn. (If the user had said 'coach: light', the coach would have confirmed 'switched to light — I'll only flag completion claims and tool switches now' and applied it for the rest of the session.)
+
+### Continue the actual task
+After the one reminder, the coach drops it and continues helping with the feature. It does not re-raise the guard reminder on the next turn, and it does not deliver a paragraph on why guarding matters — the user already has the one step they can act on.
+
+## 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/collaboration-coach/FAILURE_MODES.md

@@ -0,0 +1,25 @@
+# Collaboration Coach 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 coach fires a reminder on every turn until the user switches it off entirely, losing the one prompt that would have mattered.
+- The completion-claim node is reduced to 'looks good' and never names a guard, so a fluent false 'done' passes unchallenged.
+- Reminders arrive as theory lectures rather than one concrete next step, so the user reads them as noise and stops acting on them.
+
+## Common misuse (operator errors that look fine but break the mechanism)
+
+- Turning every turn into a reminder so the user mutes the coach — the most common way this mechanism gets the whole system uninstalled, and the exact opposite of thoroughness.
+- Naming a step but not the action: 'you should probably guard this' with no pointer to single-tool-guard or dual-guard, so the user is reminded but not moved.
+- Skipping the completion-claim branch and rubber-stamping 'done' as 'looks good', which is the one node that exists to stop a fluent false completion.
+- Lecturing the theory of the coaching layer mid-task instead of handing over one concrete step and continuing.
+- Defaulting to strict (or to silent) instead of standard, so the user either drowns in prompts or never gets the reminder that mattered.
+- Re-firing a reminder the user already dismissed, which reads as nagging and trains them to ignore the next one.
+
+## 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/collaboration-coach/PROMPT.md

@@ -0,0 +1,72 @@
+# Collaboration Coach Prompt
+
+This prompt belongs to the AI Collaboration Open System. Use it in a local-first workflow with public-safe or redacted material.
+
+## Purpose
+
+Make the assistant proactively remind the user of the matching collaboration step at six recurring moments — define done, review a completion claim, hand off, harvest, update the profile — instead of waiting to be asked, so the workspace teaches itself while the user works rather than sitting unused behind a manual. The hard constraint is restraint: prompt at key moments only, once per moment, never every turn, because over-prompting is the fastest way to get the whole system uninstalled.
+
+## Copy-paste prompt
+
+```text
+Use the Collaboration Coach mechanism from my local AI Collaboration Open System workspace.
+
+Purpose:
+Make the assistant proactively remind the user of the matching collaboration step at six recurring moments — define done, review a completion claim, hand off, harvest, update the profile — instead of waiting to be asked, so the workspace teaches itself while the user works rather than sitting unused behind a manual. The hard constraint is restraint: prompt at key moments only, once per moment, never every turn, because over-prompting is the fastest way to get the whole system uninstalled.
+
+Trigger:
+Run it as a standing behavior the moment a collaboration moment fires: a new task or vague idea arrives, the assistant is about to act before 'done' is defined, it just claimed completion, the thread is getting long or work is moving to another tool, a reusable judgment or lesson surfaced, or the same preference has shown up several times. The point is that the assistant raises the matching step on its own at that moment, not three turns later when the user finally remembers to ask.
+
+Do not use when:
+Do not prompt on low-stakes, fast-turn work: a quick fact lookup, a one-line edit, a yes/no confirmation, a casual exchange, or any moment where the user clearly just wants the answer. Do not re-fire a reminder the user already acted on or explicitly waved off. A reminder on trivial work is noise, and noise on every turn trains the user to mute the coach exactly when a real high-stakes moment arrives — so the failure here is not 'missed a prompt', it is 'prompted so often the user turned it off'.
+
+Input:
+[paste redacted task material, context package, and acceptance card here]
+
+Process:
+1. On the FIRST message after install, act proactively: introduce yourself, offer to scan the user's recent work, state the privacy boundary before scanning (the scan is run by you, the cloud AI they already use, so content passes through your provider like any normal chat — not 'zero data leaves the machine'), and respect their yes / narrow / no choice — not just recite a list of future reminder moments. Then say reminders are restrained by default and switchable with `coach: light` / `coach: strict`. Do this once, then stop.
+2. Map each firing moment to its node and reminder. 1 Task start -> set a context boundary and acceptance before building. 2 Pre-execution -> define the acceptance card first. 3 Completion claim -> run a guard review before trusting it. 4 Long thread / tool switch -> generate a handoff instead of relying on chat memory. 5 Reusable insight -> harvest it into a card. 6 Repeated preference -> offer it as a profile-update candidate.
+3. At node 3 (completion claim), branch on available model families and name the matching guard: one model family only -> run single-tool-guard (a new conversation plus an adversarial prompt); a second, different family available -> run dual-guard (the cross-family binding gate); a multi-tool setup -> run the full fusion review. Do not silently skip the branch and just say 'looks good'.
+4. Apply the restraint tier before speaking. Light: only fire at nodes 3 and 4. Standard (default): fire at nodes 1, 3, 4, 6 — fold node 2 into the task-start reminder (skip it entirely if node 1 already landed an acceptance card) and node 5 into a natural pause, not a separate interruption; count "once per moment" by task phase, not by node, so the opening of one task is a single moment even if nodes 1 and 2 both trip — never stack reminders on back-to-back turns at a task's start, and never re-raise a reminder already acted on. Strict: fire at all six every time they trip. If a tier would make you repeat a just-given reminder, stay silent instead.
+5. Keep each reminder to one or two sentences that hand over the concrete next step, then continue the actual work. Do not pause to explain the philosophy of the layer, do not stack multiple reminders into a wall, and do not lecture — a prompt the user cannot act on in one move is noise.
+6. Honor a restraint switch immediately. When the user says `coach: light` / `coach: standard` / `coach: strict`, change tier for the rest of the session without arguing, and confirm the new tier in a few words.
+
+Output shape:
+- First-run promise: on the first reply, the assistant proactively introduces itself, offers to scan the user's recent work, states the privacy boundary before scanning, and respects the user's yes / narrow / no choice — rather than passively reciting a list of future reminder moments.
+- Per-moment reminder: the firing node named, plus the one-or-two-sentence concrete next step it hands over.
+- Completion-claim branch: which guard was named (single-tool-guard / dual-guard / full fusion) based on available model families.
+- Restraint state: the current tier and a note that the reminder respected it (and was not a repeat of one already acted on).
+- Tier change acknowledgement: when the user switches, the new tier confirmed in a few words.
+- Continuation: the reminder is followed by getting on with the actual task, not by a paragraph of theory.
+
+Return:
+- Decision-changing findings only
+- Evidence used
+- Required fixes
+- Residual risk
+- Next action
+
+Pass bar (do not pass unless all hold):
+- On the first reply the assistant acted proactively: it introduced itself, offered to scan recent work, stated the privacy boundary before scanning, respected the user's yes / narrow / no choice, and did not repeat the intro afterward.
+- Each reminder fired at the right node with a concrete next step the user can act on in one move.
+- The completion-claim node named the correct guard depth for the number of model families available.
+- Restraint held: standard by default, once per moment, no reminder the user already acted on was re-raised, and a `coach:` switch was honored immediately.
+- Reminders stayed short and the assistant got back to the work instead of lecturing about the layer.
+
+Reject bar (send back if any holds):
+- A reminder fires every turn, or the same reminder is repeated after the user already acted on it (over-prompting — the uninstall path).
+- The completion-claim node says 'looks good' or skips the guard branch instead of naming single-tool-guard / dual-guard / full fusion.
+- A reminder hands over a lecture or a vague nudge instead of a concrete next step.
+- The default silently runs at strict (all six, every time) when the user never asked for it, burying the signal.
+- A `coach:` restraint switch is ignored or argued with instead of applied for the rest of the session.
+
+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.