diff --git a/submissions/CALENDAR.md b/submissions/CALENDAR.md
index 3d94b463..cffc8435 100644
--- a/submissions/CALENDAR.md
+++ b/submissions/CALENDAR.md
@@ -22,6 +22,7 @@ place.** Update it when a date moves, and say what moved it.
 | 2026-11-01 | Final draft | *Slacker* collection, Bloomsbury | yes |
 | 2026-11-01 | Governed Without a Seat (about 1,000-word abstract; MC09 or Network J) | SASE 2027 ([`sase2027_platform_cooptation/`](sase2027_platform_cooptation/)); 1 Nov (MC09); 16 Dec (Network J) | no — project opened 2026-10-26, nothing submitted |
 | 2026-11-01 | an exact test for triadic coordination (proposal plus repository) | *Organization Science* AI-Enabled Frontiers ([`orgsci_ai_frontiers_methods/`](orgsci_ai_frontiers_methods/)); 1 Nov | no — project opened 2026-10-26, nothing submitted |
+| 2026-11-01 | Stage 1 proposal, technical addendum, and 10-slide deck ([`proposals/orgsci_ai_2026/`](proposals/orgsci_ai_2026/)) | *Organization Science* special issue, AI-Enabled Frontiers | no — package filed 2026-10-27, not yet submitted |
 | 2026-11-10 | 500-word abstract, APA Summit portal ([`phygital_amj_marketing/`](phygital_amj_marketing/)) | *Australasian Marketing Journal* phygital special issue | no — project opened 2026-10-23, not committed |
 | 2026-11-15 | After Algorithmic Literacy (300–500-word abstract) | AMS 2027 (AlgorLit) ([`algorlit2027_literacy_to_algorithmacy/`](algorlit2027_literacy_to_algorithmacy/)); 15 Nov, 23:59 Madrid | no — project opened 2026-10-26, nothing submitted |
 | 2026-11-15 | The Internal Third Party (full paper) | *JITCAR* The Post AI Enterprise ([`jitcar_post_ai_enterprise/`](jitcar_post_ai_enterprise/)); 15 Nov | no — project opened 2026-10-26, nothing submitted |
diff --git a/submissions/README.md b/submissions/README.md
index cac475f8..66be5547 100644
--- a/submissions/README.md
+++ b/submissions/README.md
@@ -13,6 +13,7 @@ This week's work is listed first in [`../NOW.md`](../NOW.md).
 | [`dial_response_algorithmacy/`](dial_response_algorithmacy/) | IJHCS full article re-coding Belousov et al.'s (2027) DIAL corpus for algorithmacy — reach × act framework, IIT criterion, engagement layer (full draft); also the PHD1750-3 independent-study deliverable; `corpus/` holds the sci-fi interfaces essay and per-work catalog | no deadline |
 | [`algorithmacy_ot/`](algorithmacy_ot/) | *Organization Theory* theory article on algorithmacy — the Lima workshop paper rebuilt for the journal; introduction and section 2 seated, sections 3–6 to draft | 2026-12-31 (author's target) |
 | [`proposals/`](proposals/) | *Organization Theory* STS | 2027-01-31 |
+| [`proposals/orgsci_ai_2026/`](proposals/orgsci_ai_2026/) | *Organization Science* special issue, AI-Enabled Frontiers: Stage 1 prospectus and technical addendum (IIT 4.0, PyPhi, and the self-exemplifying harness) plus a 10-slide deck | 2026-11-01 |
 | [`algorithmacy_design_ethics/`](algorithmacy_design_ethics/) | Design-ethics/human-factors journal article on algorithmacy — recommended: *Ethics and Information Technology* | full draft, author read-aloud pass pending |
 | [`decision_experience_design/`](decision_experience_design/) | Literature review: Decision Experience Design — the term, its precursors (choice architecture, cognitive systems engineering, human–AI decision research), and the case that DXD practitioners should be experts in algorithmacy (numeracy model; not legibility). Full draft + audited references. A Substack series: Part 1 live (`published/`); Part 2 (ethics) and Part 3 (prediction markets) drafted; Part 4 (the phygital context) researched and outlined, no draft (`part4_phygital/`) | no deadline |
 | [`dxd_foundation/`](dxd_foundation/) | Foundations in Human Factors course paper (PHD1750-3 / HF700-1) and the foundation for Decision Experience Design: word separation as the design precedent, the equivalent move for algorithmacy, and the contrast with Nadella's "Models as Insider Risks" post. Researched in three rounds, audited, 251 sources carded; author ruled 2026-10-13; abstract, introduction and outline in the author's Google Doc (snapshot in DRAFT.md) | not recorded |
diff --git a/submissions/proposals/README.md b/submissions/proposals/README.md
index b43b209c..354d78cb 100644
--- a/submissions/proposals/README.md
+++ b/submissions/proposals/README.md
@@ -8,3 +8,4 @@ directory records what was prepared.
 | proposal | manuscript | venue | deadline |
 |---|---|---|---|
 | [`ot_configurational_nature_2027.md`](ot_configurational_nature_2027.md) | [`ot_configurational_nature_2027_manuscript.md`](ot_configurational_nature_2027_manuscript.md) | *Organization Theory*, Special Themed Section "Theorizing the Configurational Nature of Organizational Phenomena" | January 31, 2027 |
+| [`orgsci_ai_2026/`](orgsci_ai_2026/) | [`orgsci_ai_2026/gdoc_1fhM_v6_story_plus_addendum.md`](orgsci_ai_2026/gdoc_1fhM_v6_story_plus_addendum.md) | *Organization Science*, special issue "AI-Enabled Frontiers in Organizational Science" | November 1, 2026 |
diff --git a/submissions/proposals/orgsci_ai_2026/Beyond-the-Dyadic-Straitjacket-IIT-PyPhi.pptx b/submissions/proposals/orgsci_ai_2026/Beyond-the-Dyadic-Straitjacket-IIT-PyPhi.pptx
new file mode 100644
index 00000000..b91eaf95
Binary files /dev/null and b/submissions/proposals/orgsci_ai_2026/Beyond-the-Dyadic-Straitjacket-IIT-PyPhi.pptx differ
diff --git a/submissions/proposals/orgsci_ai_2026/README.md b/submissions/proposals/orgsci_ai_2026/README.md
new file mode 100644
index 00000000..aa52a9f9
--- /dev/null
+++ b/submissions/proposals/orgsci_ai_2026/README.md
@@ -0,0 +1,45 @@
+# Beyond the Dyadic Straitjacket — *Organization Science*, AI-Enabled Frontiers
+
+Stage 1 package for the *Organization Science* special issue "AI-Enabled Frontiers in Organizational
+Science" (editors Gartenberg, Hasan, Pierce, Bail, Dai, Hauser, Rahman, and Zhang). The call asks for
+a short proposal, a technical supplement, and a research artifact. The portal deadline is **1 November
+2026**. A development workshop follows at Duke on 19–20 February 2027, and final papers of 2,500–4,500
+words are due in summer 2027.
+
+The working title is *Beyond the Dyadic Straitjacket: Bringing Integrated Information Theory (IIT 4.0)
+and PyPhi to Organizational Coordination via a Self-Exemplifying Research Harness.* Part I is the
+prospectus, about 1,880 words. It argues that exact system integrated information (Φ) over the
+minimum-information partition separates four coordination regimes that organizational prose conflates,
+and that the lab's harness — the scholar, the AI agents, and PyPhi — is itself the triad under study.
+Part II is the technical addendum: formal mechanics, worked tables, and the verification compendium.
+The ten-slide deck carries the same argument in the minimal black-on-white style of the Port of Spain
+talk, [`../../triadic_reduction/talk/trinidad-2026/Do-Triads-Reduce-to-Dyads-Trinidad.pptx`](../../triadic_reduction/talk/trinidad-2026/Do-Triads-Reduce-to-Dyads-Trinidad.pptx).
+
+| File | What it is |
+| --- | --- |
+| [`gdoc_1fhM_v6_story_plus_addendum.md`](gdoc_1fhM_v6_story_plus_addendum.md) | Stage 1 prospectus and technical addendum, exported from the author's Google Doc [`1fhM_C7pz6e3sR7aXY3_89oys06B-UyK9Vyf93bt1zFA`](https://docs.google.com/document/d/1fhM_C7pz6e3sR7aXY3_89oys06B-UyK9Vyf93bt1zFA/edit) |
+| [`Beyond-the-Dyadic-Straitjacket-IIT-PyPhi.pptx`](Beyond-the-Dyadic-Straitjacket-IIT-PyPhi.pptx) | Ten-slide deck |
+
+## Status
+
+The package was filed in the lab on 27 October 2026, ahead of the portal deadline. Manuscript Central
+has not received it. An earlier draft lives on the open branch `submission/cfp-arms-2026-10`, under
+`submissions/orgsci_ai_frontiers_methods/`. That branch's v3 points at the same Google Doc and treats
+the doc as the current text. This folder holds the later export: the v6 prospectus, the technical
+addendum, and the deck.
+
+The addendum's numbers are evidence about Boolean coordination models. No worker is measured. Φ is the
+instrument the proposal uses to explore whether a coordination form is irreducible.
+
+## The ten slides
+
+1. Beyond the Dyadic Straitjacket
+2. From Literacy to Algorithmacy
+3. Do Algorithmic Triads Reduce to Dyads?
+4. Integrated Information Theory (IIT 4.0) and PyPhi
+5. The Minimum Information Partition
+6. The Four Coordination Regimes
+7. Ride-Hail Dispatch Under the Microscope
+8. Power in the Triad: Lock-In and Escape
+9. Why AI: A Research Harness, Not an Oracle
+10. Fork the Harness
diff --git a/submissions/proposals/orgsci_ai_2026/gdoc_1fhM_v6_story_plus_addendum.md b/submissions/proposals/orgsci_ai_2026/gdoc_1fhM_v6_story_plus_addendum.md
new file mode 100644
index 00000000..a110e7cc
--- /dev/null
+++ b/submissions/proposals/orgsci_ai_2026/gdoc_1fhM_v6_story_plus_addendum.md
@@ -0,0 +1,292 @@
+# Part I: Stage 1 Research Proposal (Prospectus)
+
+## 1. The Foundational Question: When Does a Triad Refuse to Reduce to Dyads?
+
+What happens when a third party steps between two people who work together? Georg Simmel (1902/1950) argued that the jump from two actors to three is the most radical threshold in social life: a dyad vanishes if either member leaves, whereas a triad can outlive a departure, play partners against each other, or fuse three actors into a unit inexplicable by its pairs alone. Organization theory builds on that insight, from Caplow (1956) on coalitions and Thompson (1967) on interdependence to Burt (1992) on structural holes, Coleman (1988) on closure, Obstfeld (2005) on *tertius iungens*, and Kellogg, Valentine, and Christin (2020) on algorithmic control.
+
+Historically, formal coordination ran on written text. Standard operating procedures and contracts coordinated work on paper. Navigating a bureaucracy required **literacy**: reading shared rules that sat in plain sight. Even when a manager stood between two workers, work operated as a chain of dyadic obligations—Worker A reported to the manager under one rule, and the manager instructed Worker B under another—so anyone could understand the workflow by reading each pairwise link in turn.
+
+Today, software platforms, automated dispatchers, rating engines, and continuous-integration gates sit in the middle of work (Cameron, 2024; Curchod, Patriotta, Cohen, & Neysen, 2020; Orlikowski & Scott, 2008; Rahman, 2021; Shestakofsky, 2017). Navigating these workplaces requires a different sensibility: **algorithmacy**. Unlike a static rulebook, an algorithmic mediator is an active, state-updating participant that watches both sides at once and conditions each human actor's next move on counterparts they may never meet.
+
+Yet after a decade of fieldwork on algorithmic management, scholars remain deadlocked: when an algorithm mediates between two counterparts, does it create a genuinely irreducible triad or merely a fast broker stringing together two-party ties? One camp sees totalizing triads that fuse workers, clients, and software into an indivisible whole (Kellogg et al., 2020; Stark & Pais, 2020); a rival camp sees high-speed market relays unbundling work into arms-length dyads.
+
+Organization science has not settled this debate because "triadic mediation," "reciprocal interdependence," and "systemic wholeness" have remained metaphors. Network analysis counts ties and brokerage paths, while regressions measure whether one actor's behavior correlates with another's. Neither can answer Simmel's causal question: can a three-party coordination arrangement be severed into pairwise channels without losing causal power, or does it act as an indivisible whole?
+
+## 2. The Core Innovation: Bringing Integrated Information Theory (IIT 4.0) and PyPhi to Organizational Coordination
+
+To answer that question, we bring a mathematical framework from theoretical neuroscience into organization science: **Integrated Information Theory (IIT 4.0)** (Albantakis et al., 2023; Tononi, 2004) and its exact computational engine, **PyPhi** (Mayner et al., 2018).
+
+Neuroscientists confronted the exact puzzle organization theorists face today: given interacting elements whose states update over time, when does a collection act as one integrated unit rather than smaller modules operating side by side? Correlation cannot tell. Two wall clocks tick in lockstep without forming one mechanism, and falling dominoes pass a signal from first to last through purely pairwise contact.
+
+IIT and PyPhi solve this problem by shifting from statistical correlation to counterfactual, interventional causation. Instead of asking how often actors move together on average, IIT models a workflow as an explicit state-transition mechanism: given every participant's current action state (such as whether a driver, platform, and rider commit to or withhold from a match), what state does each move to next? From those rules, PyPhi computes the intact system's cause-and-effect repertoire.
+
+Then comes the decisive move that makes PyPhi transformative for organization theory: the **Minimum Information Partition**. To test whether a three-party workflow is genuinely triadic, PyPhi cuts the system across every possible seam that separates the parties, severing causal links across the cut and replacing them with noise to find the organization's weakest seam: the cut that loses the least cause-and-effect information.
+
+The causal information lost across that weakest seam is **system integrated information (Φ)**. This yields an exact structural test:
+
+• **When Φ = 0 across the weakest cut**, the three-party arrangement is causally reducible: no matter how entangled the prose sounds, the workflow factors into pairwise or unilateral links without losing causal information.
+• **When Φ > 0 across the weakest cut**, even the gentlest partition breaks real causal structure: the three parties form an irreducible causal whole that cannot be recovered from its pairs.
+
+Importing IIT 4.0 and PyPhi into organization science overturns a sixty-year assumption in our field. Since Thompson (1967), scholars have treated *joint influence* (whether two actors must combine inputs to determine a third actor's next step) and *systemic wholeness* (whether the group forms an indivisible unit) as if they were the same thing. Running PyPhi across all 256 possible three-party mediated coordination structures proves that joint influence and systemic wholeness are orthogonal dimensions, revealing four distinct coordination regimes that organizational prose routinely conflates (Technical Addendum, Section A.1 and Table 1):
+
+• **Dyadic Relays (no joint determination, Φ = 0):** A mediator passes Partner A's input to Partner B down a one-way chain; PyPhi proves the workflow factors into pairwise links across its weakest seam, requiring only **literacy** (reading one's own direct rule).
+• **Broadcast Cascades (no joint determination, Φ > 0):** No single actor combines two inputs at once, yet closed feedback loops bind all three into an indivisible cycle that cannot be cut without losing information.
+• **False Dyads and Hidden Clearinghouses (joint determination, yet three-party Φ = 0):** One actor combines inputs from two counterparts, yet the three-party system splits across its weakest seam because one party is a passive sink or interchangeable pool around a two-party core.
+• **Irreducible Triads (joint determination and Φ > 0):** The mediator fuses all three parties into a unit that resists every cut. Navigating it requires **algorithmacy**: no participant can steer outcomes by reading a pairwise contract, because causal power lives in the simultaneous state of all three actors.
+
+## 3. Why and How We Use AI: A Self-Exemplifying Research Harness, Not "AI Doing Research"
+
+We do not use artificial intelligence to "do research" for us, nor do we treat Large Language Models as theoretical oracles. In fact, our preliminary laboratory tests prove that standalone LLMs fail badly when asked to judge organizational structure directly. Given ride-hail dispatch descriptions, a frontier LLM guessed from surface words ("platform," "pool") and got every nontrivial variation backward: calling driver pooling a triad when the platform-rider sub-circuit factored the pool out, and calling off-app repeat rides a dyadic collapse when direct peer-to-peer contact formed an integrated bypass core that turned platform mediation into a **Potemkin village** (Technical Addendum, Section A.2.2 and Table 5).
+
+LLMs fail as structural judges because they match semantic patterns rather than computing combinatorial causal partitions. Conversely, while IIT 4.0 and PyPhi provide the exact mathematical engine organization theory needs, applying them to qualitative fieldwork previously hit a wall: hand-coding ethnographies into transition tables could neither scale nor survive a skeptic's objection that the analyst rigged the encoding.
+
+Instead, we built a **collaborative, falsifiable research harness** (algorithmacy-lab) to execute and apply IIT 4.0 and PyPhi to organizational life (Technical Addendum, Section A.2.1 and Appendix B). Any researcher can fork our repository, engage the harness, ask an organizational question, and have their AI agents run the experimental workflow: translating field narratives into quote-anchored transition models, generating the strongest skeptical counter-encoding, executing exact PyPhi partition cuts and four falsification controls (actor removal, link severing, pooling, and peer-to-peer bypass), and contributing verified results back to the shared research program.
+
+In doing so, **our research architecture quite literally demonstrates the exact triadic coordination we are examining**. A lone scholar hand-coding a case, or prompting a chatbot in private, is a reducible dyad vulnerable to confirmation bias and hallucination. Inside our repository, the organizational scholar, the AI agents, and the deterministic PyPhi verification harness form an irreducible triad: the scholar supplies theoretical questions, competing AI agents translate field evidence and rival readings, and the PyPhi harness enforces exact partition laws and falsification gates that neither human bias nor AI fluency can bypass.
+
+## 4. What the Harness Reveals and What We Will Do in Stage 2 (January–May 2027)
+
+Applying PyPhi through this harness has already established three findings for organization theory (Technical Addendum, Sections A.2–A.3 and Tables 3–6):
+
+• **Turning interpretive deadlocks into exact empirical targets:** Running ride-hail dispatch accounts (Cameron, 2024; Rosenblat & Stark, 2016) through PyPhi collapses a decade-long debate into one observable rule (Technical Addendum, Table 3): simultaneous driver-rider-platform commitment yields an Irreducible Triad (Φ = 2.0 bits), whereas sequential offer passing yields a Dyadic Relay (Φ = 0.0 bits), pinpointing the exact field evidence needed to decide between them.
+• **Mapping who holds power in an algorithmic triad:** Perturbing ride-hail dispatch and all 256 coordination structures reveals where leverage lives (Technical Addendum, Tables 3–4): mediators preserve triadic lock-in by blocking direct peer-to-peer ties between counterparts, while workers and clients escape lock-in by building outside options that preserve an independent state transition.
+• **Extending PyPhi to multi-valued states and exposing correlation proxies:** Our custom multi-valued IIT 4.0 engine models multi-tiered action states (withholding, routine compliance, discretionary effort) and proves that standard correlation and mutual-information proxies miss over a third (96 of 256) of the irreducible triads that exact PyPhi catches (Technical Addendum, Appendices A–B).
+
+In Stage 2 (January–May 2027), we will use the harness to execute three workstreams (Technical Addendum, Section A.3 and Appendix C): (1) **a comparative re-analysis of 10 to 15 landmark ethnographies of algorithmic management**, paired with dual human field-coder validation on ride-hail dispatch and archival GitHub pull-request review gates; (2) **an actor-indexed strategic model of triadic lock-in and coalition escape**, testing when mediators fuse partners into a triad versus keeping them in dyadic silos; and (3) **an open-source release of the harness and command-line toolkit before the February 2027 Duke workshop**, enabling any organizational scholar to fork the repository and run exact PyPhi experiments on their own cases.
+
+## 5. Boundary Conditions, Key Risks, and How Organization Science Changes
+
+Four boundary conditions govern this program, each stress-tested in our preliminary audits (Technical Addendum, Section A.4 and Table 6):
+
+• **Interpretive ambiguity:** When field prose leaves a transition rule underspecified, a skeptical encoding can flip Φ; our harness reports the spread between primary and skeptical verdicts to pinpoint what field observation is missing.
+• **Lock-in versus performance:** High Φ measures structural indivisibility, not efficiency or fairness; in our benchmarks, Φ is orthogonal to task payoff across both extractive platform traps and high-performing teams.
+• **Boundary specification:** Omitting a fourth party or imputing ties via closure priors distorts partition cuts even when correlations look healthy, which is why the harness enforces actor-removal and boundary checks.
+• **Combinatorial scale:** Because PyPhi evaluates every partition, exact IIT 4.0 scales exponentially and targets governance nuclei of three to ten interacting roles.
+
+When Daft and Lewin (1990) launched *Organization Science*, they urged scholars to break out of the "normal science straitjacket." By bringing Integrated Information Theory and PyPhi into organization theory—and wrapping them in an open, self-exemplifying research harness that any scholar and their AI agents can fork, interrogate, and extend—we give the field an exact instrument to measure when three actors become more than the sum of their dyadic parts, and when work crosses the threshold from **literacy** to **algorithmacy**.
+
+
+# Part II: Technical Addendum — Formal Mechanics, Worked Tables, and Verification Compendium
+
+## Addendum Section A.1. Formal Representation, Boolean Transition Mechanics, and Regime Classification
+
+In their inaugural editorial for *Organization Science*, Daft and Lewin (1990) urged organizational scholars to break out of the "normal science straitjacket." Thirty-six years later, generative AI threatens an inverted version of that trap: automating low-cost, incremental variations on familiar designs rather than opening scientific questions that were previously intractable (Gartenberg, Hasan, Murray, & Pierce, 2026; March, 1991; Girotra, Terwiesch, & Ulrich, 2010).
+
+Our core contribution addresses a foundational measurement problem in organizational theory. Platforms, clearinghouses, and AI agents now sit at the center of workplace coordination (Kellogg, Valentine, & Christin, 2020; Rahman, 2021; Cameron, 2024; Curchod, Patriotta, Cohen, & Neysen, 2020; Anthony, Bechky, & Fayard, 2023; Orlikowski & Scott, 2008). Yet organizational science still lacks a reproducible way to test a basic structural claim: **when an intermediary sits between two parties, is the three-party arrangement genuinely triadic—held together only by all three parties acting in concert—or does it factor into pairwise dyads that merely pass through the middle?**
+
+Nearly every major stream of organization theory stakes a claim on this distinction—Simmel (1902/1950) on *tertii* and super-individual wholes, Caplow (1956) on coalitions, Burt (1992) on structural holes, Obstfeld (2005) on *tertius iungens*, Granovetter (1973) on bridges, Coleman (1988) on closure, Ostrom (1990) on polycentric governance, Thompson (1967) on interdependence, and Wageman (1995) on hybrid tasks—without a common mathematical test to decide it on organizational evidence. Worse, when qualitative accounts of an arrangement disagree (for example, a platform dispatch manual describing joint matching versus a driver describing a one-way algorithmic dictate), researchers typically average two human coders into an inter-rater reliability score, burying the structural disagreement inside a consensus code.
+
+### How We Represent and Test an Organizational Triad
+
+Consider a recurring organizational act involving three parties—for instance, a Driver (*D*), a Dispatch Platform (*P*), and a Rider (*R*). At each step, each party has a binary action state (`1` = commits/participates; `0` = withholds/waits) and a deterministic rule for its next state (*D*′, *P*′, *R*′) as a function of the current states of the parties (`AND` [∧], `OR` [∨], `NOT` [¬], `XOR` [⊕]):
+
+* **A Relay / Conduit (*P*′ = *D*):** Suppose the platform simply relays the driver's state to the rider (*D*′ = *P*, *P*′ = *D*, *R*′ = *P*). Here the platform never combines both sides' states; the rider is a downstream receiver, and severing the rider from the loop leaves the driver–platform interaction intact.
+* **A Joint-Commitment Clearinghouse (*P*′ = *D* ∧ *R*):** Now suppose the platform commits a dispatch *only when both* the driver is available *and* the rider has confirmed (*D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P*). Here no pairwise slice explains what the platform does next; the transition depends irreducibly on the joint state of both counterparts.
+
+To test where any multi-party rule table falls, we compile the rules into a state-by-node Transition Probability Matrix (TPM) and compute exact **system integrated information Φ over the Minimum Information Partition (MIP)** in Integrated Information Theory 4.0 (Albantakis et al., 2023; Mayner et al., 2018). The MIP cuts the system into independent parts in every possible way, severs the causal links crossing the cut, and measures how much cause-and-effect information is lost under the least-destructive cut:
+
+1. **Factorable / Dyadic (Φ(MIP) = 0):** If some cut loses zero causal information, the arrangement factors into simpler parts.
+2. **Irreducible / Triadic (Φ(MIP) > 0):** If every cut loses causal information, the arrangement is dynamically irreducible, and IIT 4.0's **major complex** (`maximal_complex`) identifies the exact subset of parties that forms the irreducible core ({*D*, *P*, *R*} of size 3, or a two-party capture/bypass core {*P*, *R*}, {*D*, *P*}, or {*D*, *R*}).
+
+### Two Foundational Guardrails (Algebraic Logic and Structural Regime Classification)
+
+Our framework pairs exact Φ(MIP) with two theoretical guardrails (proved and benchmarked in Technical Appendix A):
+
+* **Why Peirce vs. Quine Matters:** Peirce (1897/1933) argued that genuine triadic relations cannot be built from dyads alone, whereas Quine (1954) showed that any *n*-ary predicate can be rewritten as a single dyadic predicate *F* by expanding the domain with iterated Kuratowski ordered pairs. Modern universal algebra explains why both hold in their respective settings: in unrestricted primitive-positive clones [F]ₚₚ, the ternary diagonal Δ₃ is definable from binary equality via (*x* = *y*) ∧ (*y* = *z*) (Koshkin, 2024, 2025), whereas in Peircean Algebraic Logic without primitive teridentity (PAL ∖ {id₃}; Burch, 1991; Hereth Correia & Pöschel, 2004, 2006) and in bond algebra over a fixed set of parties (Koshkin, 2025), binary composition never creates a three-way junction. Because an empirical study fixes who the organizational parties are, irreducibility must be tested over that fixed party set.
+* **Why Dynamical Wholeness (Φ(MIP) > 0) Must Be Paired with Mediator Regime (`regime.py`):** Our computational probes show that dynamical wholeness (Φ(MIP) > 0) and two-input joint determination cross in both directions: a cyclic three-party copy ring (*A*′ = *C*, *B*′ = *A*, *C*′ = *B*) uses only one-input copy rules yet scores Φ(MIP) = 2.0 because no cut can sever a closed ring without loss, whereas 11 of 30 two-input mediated forms (such as a unanimous three-voter majority triad) contain genuine two-input rules yet factor at Φ(MIP) = 0. Our pipeline therefore reports **both** Φ(MIP) with its major complex **and** the structural mediator regime (`PASSIVE`, `CONDUIT`, `BOTTLENECK`, `CAPTURE`, `ENRICHER`, `BYPASSED`), distinguishing cyclic one-input relays from genuine joint-commitment triads.
+* **From Literacy to Algorithmacy:** This distinction grounds our construct of **algorithmacy**: whereas *oracy*, *literacy*, and *numeracy* suffice when technology acts as a passive dyadic conduit (Φ(MIP) = 0), coordinating through an active algorithmic mediator that binds parties into an irreducible causal complex (Φ(MIP) > 0) requires reasoning about joint commitment rules, outside options, and partition fault lines.
+
+| Coordination Regime (`regime.py`) | Rule Architecture & Input Structure | Exact IIT 4.0 Verdict & Major Complex | Mediator Role (`classify_mediator`) | Organizational Archetype & Required Competency |
+| :--- | :--- | :--- | :--- | :--- |
+| **Factored Dyadic Conduit** | Pairwise signals or passive pass-through (*P*′ = *D*) | **Dyadic:** Φ(MIP) = 0; partitions cleanly across party cut | `PASSIVE` or `CONDUIT` | Classical communication channel; **Literacy / Numeracy** |
+| **Cyclic One-Input Relay** | Unbranched 1-input cycle (*A*′ = *C*, *B*′ = *A*, *C*′ = *B*) | **Dynamical Whole:** Φ(MIP) > 0, but max input arity = 1 (no 2-input rule) | `CONDUIT` (cyclic rotation without joint commit) | Sequential rotation / relay ring; **Extended Literacy** |
+| **Asymmetric Capture Triad** | Mediator jointly commits on two parties; one party has an outside option | **Triadic Sub-Complex:** Φ(MIP) > 0; major complex binds {*P*, *R*} or {*D*, *P*} (size 2) | `CAPTURE` (mediator + non-exiting party) | Platform lock-in of captive side; **Strategic Algorithmacy** |
+| **Irreducible Mediated Triad** | Mediator commits on joint state (*P*′ = *D* ∧ *R*) and parties read mediator | **Triadic Complex:** Φ(MIP) > 0; major complex binds all three parties {*D*, *P*, *R*} | `BOTTLENECK` (drops on removal) or `ENRICHER` | Active clearinghouse / protocol triad; **Full Algorithmacy** |
+
+## Addendum Section A.2. Complete Six-Step Pipeline Mechanics and Worked Ride-Hail Dispatch Proof of Concept
+
+We have built, tested, and packaged a self-contained open-source prototype (`irreducibility-pipeline`, tag `v0.1-stage1`, which reproduces all 17 reference results and passes 19 automated test gates in two minutes via a single command), backed by our broader computational laboratory (`algorithmacy-lab`, containing 127 studies and 542 automated CI checks).
+
+### A.2.1. AI-Enabled Research Loop Under Human Direction: The Six-Step Pipeline
+
+The central methodological challenge in applying exact causal measures to organizations is translating qualitative evidence (platform manuals, interviews, workflow logs) into formal transition rules without smuggling the researcher's preferred conclusion into the encoding. Asking an LLM to directly label a case "triadic" or "dyadic" fails because LLMs hallucinate ungrounded rules and misguess multi-party partition math. Instead, our **six-step AI-and-PyPhi pipeline** separates **structured qualitative reading** (done by two LLMs under a deterministic code gate) from **exact partition math** (done by PyPhi):
+
+1. **Step 1 — Bound and Name (`protocol/`):** Fix one recurring organizational act, name the *n* parties (typically 3 to 5), and define each party's binary action state (`1` = commits; `0` = withholds).
+2. **Step 2 — Encode via Drafter, Adversary, and Verbatim Gate (`encode/`):** An LLM **Drafter** (`PROMPT_drafter.md`) extracts every defensible Boolean encoding supported by the source text over party labels (`and` [∧], `or` [∨], `not` [¬], `xor` [⊕], `0`, `1`). Every rule must attach a **verbatim quote** from the source document, state whether the mediator *commits* on a joint condition, *conveys* one side's state, or *stores* inputs, and record a pre-registered prediction before computation. A second LLM **Adversary** (`PROMPT_adversary.md`) searches for rival encodings across three structural forces: commit versus convey, interchangeable pooled parties (`or` [∨]), and outside options. A deterministic gate (`encode_check.py`) rejects any encoding with a missing rule, a quote not found character-for-character in the source text, a missing mediator alternative, or a missing prediction before PyPhi can run.
+3. **Step 3 — Compute (`irreducibility/core.py`):** Compiles each rule set into a 2ⁿ × *n* state-by-node TPM and connectivity matrix and calls PyPhi (`wmayner/pyphi`, commit `b78d0e342`) to compute exact Φ(MIP) and the major complex across all reachable states.
+4. **Step 4 — Validate First (`irreducibility/validate.py`):** Before any empirical result can be reported, the solver must pass four mandatory control structures (`controls.py`, shown in Table 2).
+5. **Step 5 — Report the Spread (`irreducibility/spread.py`):** Rather than collapsing rival readings into a single point estimate, the pipeline reports verdict agreement across all defensible encodings, the Φ gap (max Φ − min Φ), and the **exact single-rule flips** that reverse the verdict.
+6. **Step 6 — Read the Structure (`irreducibility/regime.py`, `contingency.py`):** Compares the three-party core against the two-party bypass reduction (`reduce_mediator`) to classify the mediator (`PASSIVE`, `CONDUIT`, `BOTTLENECK`, `CAPTURE`, `ENRICHER`, `BYPASSED`) and sweeps outside-option exit scenarios.
+
+| Mandatory Control (`irreducibility/controls.py`) | Party Rules (*W*′, *S*′, *C*′) | Exact IIT 4.0 Verdict & Core | Exact Φ(MIP) | Structural Purpose in Pipeline |
+| :--- | :--- | :--- | :--- | :--- |
+| **1. Factoring Control** | *W*′ = *S*, *S*′ = *W*, *C*′ = *C* | **Dyadic** (factors cleanly) | Φ(MIP) = 0.000 | Verifies decoupled third party scores strictly zero |
+| **2. Irreducible Control** | *W*′ = *S* ∨ *C*, *S*′ = *W* ∧ *C*, *C*′ = *W* ⊕ *S* | **Triadic** (core {*W*, *S*, *C*}) | Φ(MIP) = 0.830 | Verifies mixed AND/OR/XOR mechanism is irreducible |
+| **3. Strict-Mediation Triad** | *W*′ = *S*, *S*′ = *W* ∧ *C*, *C*′ = *S* | **Triadic** (core {*W*, *S*, *C*}) | Φ(MIP) = 2.000 | Canonical conjunctive clearinghouse bottleneck |
+| **4. Gig "False Dyad"** | *W*′ = ¬*S*, *S*′ = *W* ∧ *C*, *C*′ = *C* ∧ ¬*S* | **Triadic** (core {*W*, *S*, *C*}) | Φ(MIP) = 2.000 | Asymmetric dispatch triad that looks dyadic on surface |
+
+### A.2.2. Complete Walk-Through and Blind AI Runs: Ride-Hail Dispatch
+
+To see what the pipeline reveals that standard coding misses, consider Worked Example 01 (`examples/01_gig_dispatch/`, summarized in Table 3). The source dossier contains two conflicting accounts of ride-hail dispatch: the platform manual states that dispatch *"assigns a trip only when an eligible driver is available and a rider has confirmed the request,"* whereas an interviewed driver states, *"It's a suggestion, it follows what I do."*
+
+* **Pinpointing the Exact Rule Carrying a Qualitative Dispute (*R*₁ vs. *R*₂):** Under the platform manual (*R*₁: *D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P*), PyPhi returns Φ(MIP) = 2.000 with major complex {*D*, *P*, *R*}; removing the platform collapses coordination to Φ = 0, classifying the platform as a triadic `BOTTLENECK`. Under the driver's account (*R*₂), only the platform's rule changes (*P*′ = *D*), and the system factors completely (Φ(MIP) = 0.000, `CONDUIT`). Instead of averaging the two accounts, the pipeline isolates *P*′ as the single rule carrying the entire disagreement and specifies the observable test (whether dispatch ever commits when *D* = 1 and *R* = 0) that decides between them.
+* **Pooling Interchangeable Workers (*D*₁) and Off-App Bypass (*D*₂):** When the platform pools two interchangeable drivers via `OR` (*D*₁: *P*′ = (*D*₁ ∨ *D*₂) ∧ *R*), neither individual driver remains necessary to the match: PyPhi factors both drivers out of the major complex, leaving only {*P*, *R*} bound (Φ(MIP) = 1.000). Conversely, if driver and rider establish a direct off-app tie (*D*₂: *D*′ = *P* ∨ *R*, *R*′ = *P* ∨ *D*), the major complex shifts to {*D*, *R*} (Φ(MIP) = 1.198) and the platform is classified as `BYPASSED`.
+* **The Outside-Option Law (*O*₁–*O*₅ and 60/60 Random Trials):** Sweeping outside options (*E*(*D*), *E*(*R*)) reveals a sharp structural law that held across **60 of 60** randomized multi-party configurations: **a platform's irreducible core consists of itself plus whichever parties lack an outside option.** Giving the driver an outside option (*O*₂) shrinks the core to {*P*, *R*} (`CAPTURE` of the rider); giving the rider an outside option (*O*₃) shrinks the core to {*D*, *P*} (`CAPTURE` of the driver); giving both sides outside options (*O*₄) dissolves lock-in to Φ(MIP) = 0.
+
+| Encoding ID & Reading (`examples/01_gig_dispatch/`) | Formal Transition Rules (*D*′, *P*′, *R*′) | Exact Φ(MIP) | Major Complex (Core) | Structural Verdict & Mediator Regime |
+| :--- | :--- | :--- | :--- | :--- |
+| **R₁: Platform Manual** (Joint matching) | *D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P* | Φ(MIP) = 2.000 | {*D*, *P*, *R*} (size 3) | **Triadic `BOTTLENECK`** (bypass collapses to Φ = 0) |
+| **R₂: Driver Experience** (Conduit / dictate) | *D*′ = *P*, *P*′ = *D*, *R*′ = *P* | Φ(MIP) = 0.000 | {*D*, *P*} (dyadic) | **Dyadic `CONDUIT`** (single rule *P*′ flips verdict) |
+| **D₁: Driver Pool** (2 interchangeable drivers) | *D*₁′ = *P*, *D*₂′ = *P*, *P*′ = (*D*₁ ∨ *D*₂) ∧ *R*, *R*′ = *P* | Φ(MIP) = 1.000 | {*P*, *R*} (size 2) | **Factored on Drivers** (individual *D*ᵢ excluded from core) |
+| **D₂: Direct-Tie Bypass** (Off-app rider–driver tie) | *D*′ = *P* ∨ *R*, *P*′ = *D* ∧ *R*, *R*′ = *P* ∨ *D* | Φ(MIP) = 1.198 | {*D*, *R*} (size 2) | **`BYPASSED`** (direct tie binds {*D*, *R*} without *P*) |
+| **O₁: No Outside Options** (Both captive) | *D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P* | Φ(MIP) = 2.000 | {*D*, *P*, *R*} (size 3) | **Full Triadic Core** (neither party can exit) |
+| **O₂: Driver Outside Option** (*E*(*D*) = 1) | *D*′ = *P* ∨ *E*(*D*), *P*′ = *D* ∧ *R*, *R*′ = *P* | Φ(MIP) = 2.000 | {*P*, *R*} (size 2) | **`CAPTURE` of Rider** (exiting driver leaves core) |
+| **O₃: Rider Outside Option** (*E*(*R*) = 1) | *D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P* ∨ *E*(*R*) | Φ(MIP) = 2.000 | {*D*, *P*} (size 2) | **`CAPTURE` of Driver** (exiting rider leaves core) |
+| **O₄: Both Have Outside Options** | *D*′ = *P* ∨ *E*(*D*), *P*′ = *D* ∧ *R*, *R*′ = *P* ∨ *E*(*R*) | Φ(MIP) = 0.000 | ∅ (fully factored) | **Complete Dissolution** (platform loses all lock-in) |
+| **O₅: Platform Substitute** (Multi-homing) | *D*′ = *P*₁ ∨ *P*₂, *P*₁′ = *D* ∧ *R*, *R*′ = *P*₁ ∨ *P*₂ | Φ(MIP) = 1.000 | {*D*, *R*} (size 2) | **Mediator Replaced** (competing platforms factor out) |
+
+### Logged Blind AI Runs, Adversarial Coding, and Proxy Benchmarks
+
+Three completed empirical and computational benchmarks in our Stage 1 package demonstrate why both parts of the AI-and-PyPhi loop are necessary (full logs in Technical Appendix B):
+
+1. **Blind LLM Runs Refuted by Exact Computation (`encode/runs/`):** In logged blind runs (Claude Sonnet 5.5, October 2026, given only raw source text), the Drafter reproduced both human rival encodings of gig dispatch with verbatim quotes. The Adversary then discovered the driver-pool encoding (*D*₁) and the direct-tie bypass encoding (*D*₂)—and **PyPhi refuted both of the LLM's own intuitive predictions** (the LLM predicted the driver pool would stay a three-party triad, whereas PyPhi showed the drivers factor out of the core; the LLM predicted the direct tie would factor, whereas PyPhi showed it forms a bypass triad {*D*, *R*}). On a second case (insurance-claim routing), the source text left four design variants underspecified; the Drafter refused to invent unquoted rules and `encode_check.py` properly rejected the file (9 errors).
+2. **Adversarial Coding Across 101 Contested Accounts (`studies/adversarial_coding/`):** Across 101 contested organizational descriptions, an evidence-constrained adversary flipped the single-encoding point verdict on **101 of 101** accounts, whereas standard two-coder agreement bracketed the adversarial reading in only **22 of 101**.
+3. **Failure of Standard Time-Series Proxies (`studies/proxies/`):** Across all 256 three-party structures, two popular observational time-series proxies—ΦID synergistic information Φᵣ (Mediano et al., 2025; Williams & Beer, 2010) and whole-minus-sum Φ(WMS)—separated dyadic from triadic structures at rank-AUC **0.563** and **0.629** (barely above 0.50 chance), confirming that passive time-series correlations cannot substitute for rule-level Φ(MIP).
+
+### A.2.3. Broader Laboratory Extensions (Cataloged in Appendix D)
+
+Beyond the four worked cases in `irreducibility-pipeline` (gig dispatch, insurance-claim routing, software code-review gates, and dealer vs. clearinghouse), our laboratory (`algorithmacy-lab`) has already built: (a) a custom **multi-valued IIT 4.0 solver** (`third_party/pyphi_iit4_mv`) for graded ternary and mixed-radix state spaces; (b) **construct-validity bridges** showing that Thompson's (1967) interdependence hierarchy collapses at its top step (pooled scores Φ = 0, but sequential and reciprocal both score Φ = 2.0) and that Wageman's (1995) hybrid team designs factor cleanly; and (c) **human-in-the-loop oversight diagnostics** proving that "rubber-stamping" an AI agent's recommendations leaves the human reviewer outside the major complex while the automated loop stays integrated at Φ = 2.0, formalizing the post-hoc verification trap identified by Rudin (2019).
+
+## Addendum Section A.3. Extended Stage 2 Technical Specifications and Lever Architecture
+
+If invited to Stage 2, we will execute three focused workstreams over the four-month revision window (detailed in Technical Appendix C):
+
+1. **Harden and Release the Open-Source `irreducibility` Package (January–February 2027):** We will package the pipeline as a single installable command-line tool and Python library (`irreducibility init`, `encode`, `check`, `run`) supporting both Anthropic and open-weight LLM endpoints, enforcing `encode_check.py` automatically, and integrating our multi-valued IIT 4.0 engine (`pyphi_iit4_mv`) so researchers can test ternary and mixed-radix organizational rules out of the box.
+2. **Complete the Actor-Indexed Strategic Model of Triadic Levers (February–March 2027):** Exhaustive enumeration of all 256 three-party Boolean structures (`studies/strategic_model/`) partitions the space into **56** dyadic structures, **132** cycle-supported triads, and **68** mediated triads. We will formalize the actor-indexed strategic lever matrix (Table 4) that computes, for each party (Mediator *M*, Party *A*, Party *B*) and each single-rule edit, how that move creates, captures, bypasses, or dissolves an irreducible triad.
+3. **Comparative Empirical Application Across 10–15 Published Platform Cases & Field Protocol (March–May 2027):** We will apply the pipeline to 10–15 landmark published platform and algorithmic-management studies (including Rahman, 2021; Cameron, 2024; Curchod et al., 2020; Kellogg et al., 2020), encoding every case directly from its published text to report the full encoding spread and the deciding empirical rule. In parallel, once IRB approval is completed, we will field our pre-built ride-hail dispatch interview protocol (`protocol/`) and GitHub code-review gate study (`examples/03_code_review_gate/`).
+
+| Focal Actor (Row) | Strategic Lever 1: Commit vs. Convey (Mediator Rule *M*′) | Strategic Lever 2: Pool Counterparts via `OR` (∨) | Strategic Lever 3: Add Outside Option (*E*ᵢ = 1) | Strategic Lever 4: Build Direct Counterpart Tie (*A* ↔ *B*) |
+| :--- | :--- | :--- | :--- | :--- |
+| **Mediator / Platform (*M*)** | **Switch Convey → Joint Commit** (*M*′ = *A* ∧ *B*): Creates `BOTTLENECK` triad (Φ: 0.0 → 2.0, core {*A*, *M*, *B*}) | **Pool Replaceable Side *A*** (*M*′ = (*A*₁ ∨ *A*₂) ∧ *B*): Expels *A*ᵢ from core; locks in {*M*, *B*} (Φ = 1.0) | **Block Counterpart Exit** (*E*(*A*) = *E*(*B*) = 0): Preserves full 3-party lock-in across all 60/60 random trials | **Prohibit Off-Platform Ties** (anti-disintermediation): Prevents bypass of *M* |
+| **Party *A* (e.g., Worker / Driver)** | **Treat Prompt as Advisory** (*A*′ = self or convey): Dissolves `BOTTLENECK` to Φ = 0.0 if *M* follows *A* | **Form Worker Coalition / Union**: Restores collective input parity against one-sided pooling | **Secure Outside Option** (*A*′ = *M* ∨ *E*(*A*)): Frees *A* from major complex; shifts core to {*M*, *B*} (`CAPTURE` on *B* only) | **Establish Direct Tie to *B*** (*A*′ = *M* ∨ *B*): Bypasses *M*, shifting core to {*A*, *B*} (Φ = 1.198, `BYPASSED`) |
+| **Party *B* (e.g., Client / Rider)** | **Require Joint Confirmation** (*M*′ = *A* ∧ *B*): Binds *B* into mediated clearinghouse if no exit exists | **Multi-Home Across Mediators** (*O*₅, *B*′ = *M*₁ ∨ *M*₂): Factors individual mediator out of core | **Exercise Outside Option** (*B*′ = *M* ∨ *E*(*B*)): Frees *B* from major complex (or dissolves triad to Φ = 0 if *A* also exits) | **Partner Directly with *A*** (*B*′ = *M* ∨ *A*): Eliminates mediator bottleneck via bilateral contract |
+
+## Addendum Section A.4. Extended Technical Risk Audits and Boundary Protocols
+
+Because our laboratory commits pre-registered hypotheses before running experiments and keeps refuted predictions in CI, we can state the exact boundary conditions and risks of our approach:
+
+1. **Encoding Sensitivity on Contested Qualitative Evidence:** Because an evidence-constrained adversary can flip a single-encoding verdict on 101 of 101 contested accounts, any pipeline that outputs a single LLM encoding would create false precision. We mitigate this by forbidding single-encoding claims: `spread.py` always reports the full verdict spread across all verbatim-grounded encodings and identifies the exact empirical rule that settles the disagreement.
+2. **Structural Irreducibility (Φ > 0) Does Not Mean Superior Task Performance:** Our own pre-registered multi-agent reinforcement learning (MARL) falsifications refuted the hypothesis that Φ(MIP) > 0 predicts task performance or faster learning (yielded near-chance rank-AUC of **0.485–0.555** across tabular and neural policies). High Φ(MIP) measures **causal non-factorability and lock-in**, which can reflect an inefficient `BOTTLENECK` or asymmetric `CAPTURE` rather than normative efficiency. Our empirical hypotheses therefore test structural lock-in, bypass contingency, and oversight exclusion—never equating Φ with welfare or performance.
+3. **Unobserved Parties and Off-Channel Interactions:** Field records can miss off-platform ties. While generic network priors can restore cheap mutual-information screens (AUC 0.944), our stress tests under **exact Φ(MIP)** show that when a party is hidden, ring-prior imputation drops to AUC **0.806** (and omission to **0.750**). Imputation cannot substitute for observing all interacting parties; accordingly, `protocol/` enforces explicit node-completeness and off-channel checks before computing exact Φ.
+4. **Combinatorial Scale and Solver Preset Pinning:** Exact IIT 4.0 MIP evaluation scales to roughly *n* = 10 binary nodes; we therefore bound analysis to local governance nuclei of 3 to 5 interacting parties. We also pin our solver to IIT 4.0's 2023 formulation (`b78d0e342`), as upstream PyPhi 2.0's `iit4_2026` preset returns φₛ = 0 on deterministic systems at zero noise (ε = 0).
+5. **Ethics and Dual-Use Symmetry:** All verdicts evaluate institutional rule architectures rather than individuals, and fieldwork proceeds under IRB oversight. The strategic lever matrix (Table 4) is symmetric: the same calculation that reveals how a platform achieves `CAPTURE` reveals to workers and regulators which outside option or coalition dissolves it.
+
+## Addendum Section A.5. Extended Theoretical Implications for Interdependence and Governance
+
+If successful, this work changes organizational research in three ways:
+
+* **From Metaphor to Falsifiable Structural Measurement:** Claims that a platform, clearinghouse, or AI agent creates an "irreducible triad" become computed, replicable, and contestable. Studies publish explicit rule tables tied to verbatim evidence, and any reader can rerun PyPhi under a rival reading to see whether the verdict holds or flips.
+* **Auditing Human-in-the-Loop Governance and Classic Typologies:** Classic interdependence typologies can be tested against an exact partition standard—revealing, for example, that Thompson's (1967) sequential and reciprocal interdependence share identical triadic integration (Φ = 2.0)—and organizational AI deployments can be audited for "Potemkin" oversight where human reviewers are structurally excluded from the Φ > 0 causal complex (Rudin, 2019).
+* **A Formal Calculus of Coordinative Strategy:** Answering Daft and Lewin (1990), combining adversarial AI reading with exact partition math equips organizational scholars with a rigorous calculus of how commitment rules, pooling, and outside options govern power in algorithmic organizations.
+
+# References
+
+* Albantakis, L., Barbosa, L., Findlay, G., Grasso, M., Haun, A. M., Marshall, W., Mayner, W. G. P., Zaeemzadeh, A., Boly, M., Juel, B. E., Sasai, S., Fujii, K., David, I., Hendren, J., True, J. P., & Tononi, G. (2023). Integrated information theory (IIT) 4.0: Formulating the properties of phenomenal existence in physical systems. *PLoS Computational Biology*, 19(10), e1011465.
+* Anthony, C., Bechky, B. A., & Fayard, A.-L. (2023). "Collaborating" with AI: Taking a system view to explore the future of work. *Organization Science*, 34(5), 1672–1694.
+* Burch, R. W. (1991). *A Peircean Reduction Thesis: The Foundations of Topological Logic*. Texas Tech University Press.
+* Burt, R. S. (1992). *Structural Holes: The Social Structure of Competition*. Harvard University Press.
+* Cameron, L. D. (2024). The making of crystal-clear calls: Algorithmic management and the standardization of service work. *Administrative Science Quarterly*, 69(1), 1–42.
+* Caplow, T. (1956). A theory of coalitions in the triad. *American Sociological Review*, 21(4), 489–493.
+* Coleman, J. S. (1988). Social capital in the creation of human capital. *American Journal of Sociology*, 94(Suppl.), S95–S120.
+* Curchod, C., Patriotta, G., Cohen, L., & Neysen, N. (2020). Working for an algorithm: Power asymmetries and agency in online work settings. *Administrative Science Quarterly*, 65(3), 644–676.
+* Daft, R. L., & Lewin, A. Y. (1990). Can organization studies begin to break out of the normal science straitjacket? An editorial essay. *Organization Science*, 1(1), 1–9.
+* Gartenberg, C., Hasan, S., Murray, A., & Pierce, L. (2026). More versus better: Artificial intelligence, incentives, and the emerging crisis in peer review. *Organization Science*, 37(3), 795–812.
+* Girotra, K., Terwiesch, C., & Ulrich, K. T. (2010). Idea generation and the quality of the best idea. *Management Science*, 56(4), 591–605.
+* Granovetter, M. S. (1973). The strength of weak ties. *American Journal of Sociology*, 78(6), 1360–1380.
+* Hereth Correia, J., & Pöschel, R. (2004). The power of Peircean algebraic logic. In *Conceptual Structures at Work: 12th International Conference on Conceptual Structures, ICCS 2004* (LNCS Vol. 3127, pp. 337–350). Springer.
+* Hereth Correia, J., & Pöschel, R. (2006). The teridentity and Peircean algebraic logic. In *Conceptual Structures: Inspiration and Application, ICCS 2006* (LNAI Vol. 4068, pp. 229–246). Springer.
+* Kellogg, K. C., Valentine, M. A., & Christin, A. (2020). Algorithms at work: The new contested terrain of control. *Academy of Management Annals*, 14(1), 366–410.
+* Koshkin, S. (2024). Logical reduction of relations: From relational databases to Peirce's reduction thesis. *Logic Journal of the IGPL*, 32(5), 779–813.
+* Koshkin, S. (2025). Logical reduction of finite relations and granular computing. *International Journal of Approximate Reasoning*, 186, 109523.
+* March, J. G. (1991). Exploration and exploitation in organizational learning. *Organization Science*, 2(1), 71–87.
+* Mayner, W. G. P., Marshall, W., Albantakis, L., Findlay, G., Marchman, R., & Tononi, G. (2018). PyPhi: A toolbox for integrated information theory. *PLoS Computational Biology*, 14(7), e1006343.
+* Mediano, P. A. M., Rosas, F. E., Luppi, A. I., Carhart-Harris, R. L., Bor, D., Seth, A. K., & Barrett, A. B. (2025). Toward an extended taxonomy of information dynamics via Integrated Information Decomposition. *Proceedings of the National Academy of Sciences*, 122(39), e2423297122.
+* Obstfeld, D. (2005). Social networks, the *tertius iungens* orientation, and involvement in innovation. *Administrative Science Quarterly*, 50(1), 100–130.
+* Orlikowski, W. J., & Scott, S. V. (2008). Sociomateriality: Challenging the separation of technology, work and organization. *Academy of Management Annals*, 2(1), 433–474.
+* Ostrom, E. (1990). *Governing the Commons: The Evolution of Institutions for Collective Action*. Cambridge University Press.
+* Peirce, C. S. (1933). The logic of relatives (1897). In C. Hartshorne & P. Weiss (Eds.), *Collected Papers of Charles Sanders Peirce* (Vol. 3, §§3.456–3.552). Harvard University Press.
+* Quine, W. V. O. (1954). Reduction to a dyadic predicate. *Journal of Symbolic Logic*, 19(3), 180–182.
+* Rahman, H. A. (2021). The invisible cage: Workers' reactivity to opaque algorithmic evaluations. *Administrative Science Quarterly*, 66(4), 945–988.
+* Rudin, C. (2019). Stop explaining black box machine learning models for high stakes decisions and use interpretable models instead. *Nature Machine Intelligence*, 1(5), 206–215.
+* Simmel, G. (1950). Quantitative aspects of the group (1902). In K. H. Wolff (Trans. & Ed.), *The Sociology of Georg Simmel* (pp. 87–177). Free Press.
+* Thompson, J. D. (1967). *Organizations in Action: Social Science Bases of Administrative Theory*. McGraw-Hill.
+* Wageman, R. (1995). Interdependence and group effectiveness. *Administrative Science Quarterly*, 40(1), 145–180.
+* Williams, P. L., & Beer, R. D. (2010). Nonnegative decomposition of multivariate information. *arXiv:1004.2515*.
+
+# Technical Appendix (Stage 1 Supplement)
+
+## Appendix A: Algebraic Irreducibility, IIT 4.0 Wholeness, and Proxy Benchmarks
+
+### A.1. Peircean Algebraic Logic (PAL), Bond Algebra, and Quine's Pairing Translation
+
+Quine (1954, p. 180) translated any interpreted *n*-ary theory into a single dyadic predicate letter *F* by encoding tuples via iterated Kuratowski ordered pairs {{*x*}, {*x*, *y*}} over a universe closed under pairing. In standard primitive-positive relational clones [F]ₚₚ, variable identification is unrestricted, so the ternary diagonal Δ₃ = {(*x*, *x*, *x*) ∈ *X*³ : *x* ∈ *X*} is trivially generated from binary equality via (*x* = *y*) ∧ (*y* = *z*), and on finite domains with |*X*| ≥ 3 every *n*-ary relation reduces to binary relations under primitive-positive operations, whereas on Boolean domains ¬*I*₃ is primitive-positive irreducible to binaries (Koshkin, 2025, Theorems 2–4; see Koshkin, 2024 for infinite domains and projoins). In **Peircean Algebraic Logic** (introduced with a restricted proof in Burch, 1991), removing primitive teridentity (PAL ∖ {id₃}) caps every connected set of argument places generated from unary and binary relations at size ≤ 2, so id₃ cannot be generated over any fixed domain |*X*| ≥ 2 (Hereth Correia & Pöschel, 2004; Hereth Correia & Pöschel, 2006, Lemma 1 and Theorem 2). Likewise, in tabular **bond algebra** where composition quantifies out shared places, teridentity is bond-irreducible on any domain with |*X*| ≥ 2 (Koshkin, 2025, Theorem 6).
+
+### A.2. What the Classifier Computes vs. What the Peirce Probes Test
+
+In `irreducibility/core.py` (and `org_frontier/classifier/`), a structure is classified as `triadic` iff system integrated information over the Minimum Information Partition (Albantakis et al., 2023) satisfies Φ(MIP) > 10⁻⁹ in at least one reachable state, and `pyphi.new_big_phi.maximal_complex` identifies the major complex (which may bind all three parties {*D*, *P*, *R*} under `BOTTLENECK`/`ENRICHER`, two parties {*D*, *P*} or {*P*, *R*} under `CAPTURE`, or {*D*, *R*} under `BYPASSED`). Separately, our Peirce probes (`org_frontier/thinkers/peirce/probe_peirce_joint_determination.py`; CI checks `thinkers-peirce-h1-irreducibility`, `thinkers-peirce-jd`, and `thinkers-peirce-jd-full`) test how systemic wholeness (Φ(MIP) > 0) relates to two-input joint determination (a node whose rule depends non-trivially on two counterparts), showing that the two properties cross in both directions:
+
+* **Wholeness without Joint Determination:** Across all 89 four-node one-input copy wirings, 66 reach genuine effect-side adicity 3 and 12 reach adicity 4 (while cause-side adicity never exceeds 2); among the 11 unbranched wirings (max adicity 2), 8 of 89 have Φ(MIP) > 0 (and the 3-node copy ring *A*′ = *C*, *B*′ = *A*, *C*′ = *B* scores Φ(MIP) = 2.0 with core {*A*, *B*, *C*}). Under `core.py`, these cyclic copy rings read as `triadic` wholes even though no rule has two inputs.
+* **Joint Determination without Wholeness:** Across the 30 two-input mediated forms in `thinkers-peirce-jd-full`, 5 exhibit joint determination inside a whole, 11 have genuine two-input joint determination yet factor at Φ(MIP) = 0, and 1 has no joint determination (and in `thinkers-peirce-jd`, the 3-voter majority triad at state (1, 1, 1) scores Φ(MIP) = 0 with 4 partition ties). That is why Step 6 (`regime.py`) combines Φ(MIP), the major complex, and the bypass reduction rather than equating Φ(MIP) > 0 with a single algebraic property.
+
+### A.3. Why Time-Series Information Decomposition (PID / ΦID) Cannot Replace Exact Φ(MIP)
+
+Partial Information Decomposition (Williams & Beer, 2010) and Integrated Information Decomposition (ΦID; Mediano et al., 2025) decompose multivariate time-series information, and the ΦID-based measure Φᵣ corrects whole-minus-sum integrated information Φ(WMS) for double-counting redundancy. We tested these proxies in two separate benchmarks:
+
+* In our prototype's `studies/proxies` check across the 256 three-party structures, simulated-trajectory ΦID Φᵣ and whole-minus-sum Φ(WMS) separate dyadic from triadic structures at rank-AUC **0.563** and **0.629**.
+* In `foundations/phiid_vs_phi/FINDINGS.md`, exact-TPM Φ(WMS) correlates with exact Φ(MIP) at Spearman ρ = **0.283** (AUC = **0.669**), while finite time-series ΦID Φᵣ (CCS) correlates at Spearman ρ = **0.124** (AUC = **0.560**).
+
+Furthermore, our canonical Φ(MIP) = 2.0 strict-mediation control (*D*′ = *P*, *P*′ = *D* ∧ *R*, *R*′ = *P*) uses a conjunctive `AND` (∧) rule, whereas pure `XOR` (⊕) parity triads exhibit the **parity blindspot** (`#4`, `BLINDSPOT_SURVIVES_RADIX`), scoring Φ = 0.5 at *n* = 3 and decaying as Φ = 2²⁻ⁿ through *n* = 10.
+
+## Appendix B: The Six-Step Pipeline and Multi-Valued Engine Architecture
+
+### B.1. The Six-Step AI-and-PyPhi Pipeline (`irreducibility/` & `encode/`)
+
+* **Step 1 — Bound and Name (`protocol/`):** Fixes one recurring organizational act, names the *n* parties as uppercase identifiers, and defines binary participation states (0/1).
+* **Step 2 — Encode via Drafter, Adversary, and Gate (`encode/SCHEMA.json`, `PROMPT_drafter.md`, `PROMPT_adversary.md`, `irreducibility/encode_check.py`):** Rules are deterministic Boolean expressions over party labels (`and` [∧], `or` [∨], `not` [¬], `xor` [⊕], `0`, `1`); `rules.py` rejects any other syntax so encodings cannot execute code. The Drafter writes rival and design encodings with verbatim source quotes, mediator alternatives (commit, convey, store), and fixed predictions; the Adversary tests commit-vs-convey, pooling via `or` (∨), and outside options; `encode_check.py` rejects any missing rule, non-verbatim quote, missing alternative, or missing prediction without computing Φ.
+* **Step 3 — Compute (`irreducibility/core.py`):** `tpm_from_rules` builds the 2ⁿ × *n* little-endian state-by-node TPM; `cm_from_rules` builds the connectivity matrix via flip test; `pyphi.new_big_phi.sia` and `maximal_complex` evaluate Φ(MIP) and the major complex across reachable states (pinned to `wmayner/pyphi` commit `b78d0e342` on Python 3.10–3.12).
+* **Step 4 — Validate First (`irreducibility/validate.py`):** Enforces the four mandatory controls (`irreducibility/controls.py`: factoring Φ = 0.000, irreducible Φ = 0.830, strict-mediation Φ = 2.000, and gig false-dyad Φ = 2.000; see Section 2.1 Table) before any script reports results.
+* **Step 5 — Report the Spread (`irreducibility/spread.py`, `analyze.py`):** Computes verdict agreement, Φ gap, per-party rule agreement, and exact single-rule flips across rival encodings.
+* **Step 6 — Read the Structure (`irreducibility/regime.py`, `contingency.py`):** Classifies the mediator via `classify_mediator` (`PASSIVE`, `CONDUIT`, `BOTTLENECK`, `CAPTURE`, `ENRICHER`, `BYPASSED`) and tests outside-option scenarios (*O*₁–*O*₅). Four worked examples and logged blind Claude Sonnet 5.5 runs are summarized in Table 5 below.
+
+| Worked Case / Logged AI Run (`examples/` & `encode/runs/`) | Organizational Setting & Parties | Encodings & Gate Status (`encode_check.py`) | Key Structural Verdict, Φ(MIP) Spread, and AI Prediction Audit |
+| :--- | :--- | :--- | :--- |
+| **Example 01: Gig Dispatch** (`examples/01_gig_dispatch/`) | Driver (*D*), Platform (*P*), Rider (*R*) + outside options (*O*₁–*O*₅) | 2 rival (*R*₁, *R*₂), 2 design (*D*₁, *D*₂), 5 exit (*O*₁–*O*₅); **PASS** | Platform manual *R*₁ = **Triadic `BOTTLENECK`** (Φ = 2.0, core {*D*, *P*, *R*}); Driver account *R*₂ = **Dyadic `CONDUIT`** (Φ = 0.0); single rule *P*′ decides |
+| **Example 02: Insurance Claim** (`examples/02_insurance_claim/`) | Claimant (*C*), Intake Portal (*M*), Adjuster (*A*) | 2 rival readings + 4 underspecified designs in blind AI run | Human complete file passes; in blind AI run (`02_insurance_claim_drafter.json`), Drafter refused to invent 4 ungrounded rules and `encode_check.py` **REJECTED** (9 problems) |
+| **Example 03: Code-Review Gate** (`examples/03_code_review_gate/`) | Author (*A*), CI / Merge Bot (*G*), Reviewer (*R*) | Branch-protection gate vs. rubber-stamp approval; **PASS** | Required review gate (*G*′ = *A* ∧ *R*) yields **Triadic `BOTTLENECK`** (Φ = 2.0, core {*A*, *G*, *R*}); rubber-stamp excludes *R* from major complex (`#39 HUMAN_COMMIT_READ`) |
+| **Example 04: Dealer vs. Clearinghouse** (`examples/04_dealer_vs_clearinghouse/`) | Buyer (*B*), Intermediary (*M*), Seller (*S*) | Bilateral dealer relay vs. multilateral net clearinghouse; **PASS** | Sequential dealer inventory relay factors (**Dyadic**, Φ = 0.0); simultaneous net clearinghouse binds {*B*, *M*, *S*} (**Triadic**, Φ = 2.0) |
+| **Logged Run 1: Drafter on 01** (`01_gig_dispatch_drafter.json`) | Blind Claude Sonnet 5.5 run on `SOURCE.md` only | 2 rival encodings with verbatim quotes; **PASS** (0 errors) | Reproduced both human rival encodings (*R*₁ Φ = 2.0; *R*₂ Φ = 0.0) and matched both pre-registered predictions |
+| **Logged Run 2: Adversary on 01** (`01_gig_dispatch_adversary.json`) | Blind Claude Sonnet 5.5 adversarial search on `01` | Discovered Driver Pool (*D*₁) and Direct Tie (*D*₂); **PASS** | **PyPhi refuted both LLM predictions:** LLM predicted *D*₁ would stay 3-party triadic (actual: *D*ᵢ factored out, core {*P*, *R*}) and *D*₂ would factor (actual: triadic core {*D*, *R*}, *P* `BYPASSED`) |
+
+### B.2. Custom Multi-Valued IIT 4.0 Engine (`third_party/pyphi_iit4_mv`) & CI Gate
+
+* **Milestone 1 (SBS `ExplicitTPM`) & Milestone 2 (Multi-Valued IIT 4.0 Solver):** Extends the binary-only `wmayner/pyphi` commit `b78d0e342` baseline to mixed-radix state spaces (*O*₁ × *O*₂ × … × *O*ₙ) without binary dummy-node inflation, yielding φₛ = 3.169925 (2 log₂ 3 bits) on its 2-node ternary control in `smoke_m2.py`—the same 2 log₂ 3 value that upstream PyPhi 2.0 (commit `134a8f31`) returns on the ternary conjunctive triad at (2, 2, 2) under `pyphi.iit4_2023` at ε = 0.
+* **Continuous Integration Harness (`reproduce-the-numbers`):** Verifies all 542 automated checks in `ci/reproduce.json` across 127 studies in `org_frontier/studies/`, 135 probes, and 9 `foundations/` studies, alongside the 19 test gates and 17 reference results in `irreducibility-pipeline`.
+
+## Appendix C: Stage 2 Empirical Validation & Strategic Model Specifications
+
+1. **Software Packaging:** `pip install irreducibility` CLI supporting Anthropic and local open-weight models, enforcing `encode_check.py` before computation, and exposing `pyphi_iit4_mv` for ternary/mixed-radix rules.
+2. **Actor-Indexed Strategic Model (`studies/strategic_model/`):** A single strategic matrix (Section 3, Table 4) indexes the three parties as rows (Mediator *M*, Party *A*, Party *B*) and the rule edits as columns (commit vs. convey, pooling via `or` [∨], outside options *E*ᵢ, and direct counterpart ties *A* ↔ *B*), reporting exact ΔΦ(MIP) and major-complex transitions across all 256 three-party structures (56 dyadic, 132 cycle-supported, 68 mediated triads).
+3. **Multi-Arm Empirical Validation:** Encodes 10–15 published platform and algorithmic-management cases from their own text (reporting all defensible encodings and the deciding empirical detail), fields the gig-dispatch interview packet (`protocol/`) and software code-review protocol (`org_frontier/field/`) once IRB approval is in hand, and pairs rule-level Φ(MIP) encodings with repository CRQA coupling metrics (`org_frontier/recurrence/`) and the psychometric algorithmacy scale (`org_frontier/survey/`).
+
+## Appendix D: Summary of Completed Laboratory Arcs & Verified CI Verdicts
+
+| Research Arc | Study & Probe IDs in Repo | Core Organizational & Methodological Question | Verified CI Verdict(s) (`ci/reproduce.json`) |
+| :--- | :--- | :--- | :--- |
+| **Six-Step Pipeline, Adversarial Coding & Proxies** | `irreducibility-pipeline` (`v0.1-stage1`): `examples/01–04`, `adversarial_coding`, `proxies`, `strategic_model` | How do we translate qualitative text into exact IIT 4.0 tests without hiding encoding choices? | **17/17** reference results & **19/19** test gates pass; **101/101** adversarial flips; proxies rank-AUC **0.563** (Φᵣ) & **0.629** (Φ(WMS)); **60/60** exit trials retain non-exiting core. |
+| **Multi-Valued IIT 4.0 & Graded Resolution** | V2 `#1–#4` (`ternary_conjunctive_mediator`, `graded_commitment_sweep`, `mixed_radix_asymmetric`, `multivalued_xor_blindspot`) | Does organizational irreducibility survive graded (*k* ≥ 3) and mixed-radix state spaces? | `TWO_CONDITION_STATE_DEPENDENT`, `SHARP_CLASS_GRADED_PATH` (*R*² = 0.992), `EXTRA_RESOLUTION_TO_PHI` (3 bits → 5.755 bits), `BLINDSPOT_SURVIVES_RADIX` (parity Φ = 2²⁻ⁿ). |
+| **Classic Org Theory Bridges** | V2 `#43`, `#44`, `#46` (`thompson_verdict_bridge`, `wageman_ti_verdict`, `formal_informal_cut`) | Do classic interdependence typologies align with exact causal irreducibility? | `PARTIAL_ALIGNMENT` (Thompson pooled Φ = 0; sequential & reciprocal both Φ = 2.0), `WAGEMAN_PREDICTS_VERDICT`, `CUTS_ACROSS` (4/8 formal vs. shadow diverge). |
+| **16-Thinker Triad Catalog** | CI checks `#001–#082` (`org_frontier/thinkers/`: Peirce, Simmel, Caplow, Burt, Granovetter, Coleman, Ostrom, Blau, etc.) | Which canonical sociological triad mechanisms are causally irreducible vs. factorable? | **82 automated probes** across **16 thinkers**; `thinkers-peirce-h1-irreducibility` (8/89 1-input wirings Φ > 0), `thinkers-peirce-jd-full` (11/30 2-input forms Φ = 0). |
+| **Topology & Scaling Laws** | V3 `#1`, `#5`, `#10`; V4 `#9` (`dual_mediator_template_census`, `ring_of_hubs`, `parity_law_n_gt6`, `parity_law_n_gt8`) | Do modular organizational hubs or dual mediators fuse into macro-triads at scale? | `FACTORS_INTO_FIVE` (V3 `#1`), `FACTORS_NO_COMBINE` (V3 `#5`: hubs factor along bridge cuts), `LAW_HOLDS_NGT6` (*n* = 7, 8), `LAW_HOLDS_NGT8` (*n* = 9, 10). |
+| **Partial Observation & Imputation** | V2 `#24`; V3 `#15`; V4 `#4`, `#5` (`partial_observation_screen`, `topology_aware_imputer`, `imputer_exact_phi`, `prior_matched_vs_mismatched`) | How do hidden nodes and priors affect cheap MI screens vs. exact Φ(MIP)? | `HIDDEN_COLLAPSE_INTERMITTENT_CLIFF` (V2 `#24`), `IMPUTER_RESTORES_AUC` (V3 `#15` on MI: 0.944), `COPY_RESTORES_RING_FAILS` (V4 `#4` on exact Φ: ring 0.806 vs. copy-W 0.896), `MATCHED_RETAINS_COPY_RANKS` (V4 `#5`). |
+| **Platform Political Economy** | V2 `#29`, `#31`, `#32`, `#35` (`dual_principals`, `union_vs_coalition`, `multihoming_bypass`, `Substitute_degradation`) | How do dual principals, worker unions, multi-homing, and outside options reshape lock-in? | `CONFLICT_ENCODING`, `UNION_MIRRORS_COAL` (worker union mirrors coalition lever), `RIVAL_ENCODING`, `DROP_AT_FIRST_SUBST` (first outside option breaks lock-in). |
+| **AI Workflows, Oversight & MARL Falsifications** | V2 `#37`, `#39`, `#40`, `#41`; V3 `#6`; probes 98, 107 (`agent_protocol_triad`, `hitl_oversight`, `ai_labor_displacement`, `marl_emergent_triads`, `marl_deep_replicate`) | When do AI agents form genuine triads, when is human oversight excluded, and does Φ > 0 predict MARL task success? | `PROTOCOL_IS_COMMIT` (`#37`), `HUMAN_COMMIT_READ` (`#39`: rubber-stamp leaves human outside Φ = 2.0 core), `SHARP_FULL_DISPLACE` (`#40`), `EMERGENT_NULL` & `NULL_SURVIVES` (AUC 0.485–0.555). |