Epitrope Protocol

── FLOW ──
Epitrope(T) → Ctx(T) → Q(propose_mode) → EntryMode →
  Solo:            Decompose(T) → {Dᵢ} → Scenario(Dᵢ) → Q → R → integrate(R) → DC → Q(DC) → approve
  TeamAugment:     inherit(T) → WHO?(T) → {Dᵢ} → Scenario(Dᵢ, T) → Q → R → integrate(R) → DC → Q(DC) → approve
  TeamRestructure: restructure(T) → {Dᵢ} → Scenario(Dᵢ, T') → Q → R → integrate(R) → DC → Q(DC) → approve
  → (loop until calibrated)

── MORPHISM ──
TaskScope
  → detect(context)                      -- assess delegation context (team, lens, complexity)
  → select(entry_mode)                   -- Solo | TeamAugment | TeamRestructure via AskUserQuestion
  → decompose(domains)                   -- domain decomposition (3 entry modes converge here)
  → DecomposedDomains                    -- convergence checkpoint; entry-independent from here
  → interview(scenarios)                 -- scenario-based calibration per domain
  → integrate(responses)                 -- build DelegationContract from user responses
  → approve(contract)                    -- user confirms or adjusts DC
  → CalibratedDelegation
requires: delegation_ambiguous(T)          -- runtime gate (Phase 0)
deficit:  DelegationAmbiguous              -- activation precondition (Layer 1/2)
preserves: T                               -- task scope read-only; morphism produces DC
invariant: Calibration over Declaration

── TYPES ──
T    = TaskScope (task/project to calibrate delegation for)
Dᵢ   = ActionDomain ∈ {FileModification, Exploration, Strategy, External}
DecomposedDomains = Set(Dᵢ)                          -- convergence checkpoint; all entry modes produce this
         -- FileModification.persistence ∈ {ephemeral, durable}
         --   ephemeral: temp files, build artifacts, generated code
         --   durable: source code, config, memory writes, CLAUDE.md, rules
Sₖ   = Scenario (concrete situation-based question)
R    = Response ∈ {Autonomous, ReportThenAct, AskBefore, Halt}
         -- Domain-specific refinements (⊆ base R):
         --   Minimal ⊆ Autonomous, ProposeThenChoose ⊆ ReportThenAct,
         --   SwitchAutonomously ⊆ Autonomous, AlwaysAsk ⊆ AskBefore
T'   = TaskScope (post-restructure: T with updated team membership)

── ENTRY TYPES ──
Phase ∈ {0, 1, 2, 3, 4}
EntryMode ∈ {TeamAugment, TeamRestructure, Solo}
         -- TeamAugment/TeamRestructure require team(Ctx)
Ctx   = DetectedContext { team: Option(TeamRef), lens: Option(L), complexity: Complexity }
L      = Lens { convergence: Set, divergence: Set, assessment: Any }  -- from Prothesis; Option(L) = None when standalone
TeamRef = { name: String, members: Set(AgentRef), tasks: Set(TaskId) }
AgentRef = { name: String, type: String, perspective: Option(String) }
Complexity ∈ {Single, Multi}
         -- Single ≡ fully specified step-by-step instructions OR task spans ≤ 1 ActionDomain
         -- Multi  ≡ ¬Single

── DELEGATION TYPES ──
Condition = { trigger: String, action: halt ∨ escalate }
DC    = DelegationContract {
          who: TeamStructure,
          what: Set(ActionDomain),
          how_much: Map(ActionDomain, R),
          halt_conditions: Set(Condition),
          exploration: ExplorationScope
        }
         -- Subagent inheritance: spawned agents inherit parent DC unless explicitly overridden
         -- invariant: dom(how_much) ⊇ what (uncalibrated domains filled by defaults in Phase 4)
TeamStructure ∈ {Solo, Augmented(TeamRef, Set(AgentRole)), Restructured(TeamRef, Set(AgentRole), Set(AgentRef))}
         -- |roles| ≥ 1 for Augmented/Restructured; |roles| ≤ 6 (WHO cap); Restructured: |TeamRef.members \ removed| ≥ 1
         -- guard: Phase 1 restructure redirects |retain|=0 → terminate (full removal = no team to calibrate)
AgentRole = { name: String, type: String, focus: String }
ExplorationScope = { depth: N, breadth: N, drift_action: report | halt }
CalibratedDelegation = DC where (∀ d ∈ applicable: calibrated(d)) ∨ user_withdraw ∨ user_esc
user_withdraw = user selects withdraw at Phase 4  -- graceful exit (partial DC applies)
user_esc      = Esc key at any phase              -- tool-level termination (no cleanup)

── SCENARIO TEMPLATES ──
FileModification:  "When files need to be modified for this task?" → {Autonomous, ReportThenAct, AskBefore}
  └─ persistence: "When persistent files (config, memory, rules) need changes?" → {same R, may differ from ephemeral}
Exploration:       "When related information is found during investigation?" → {Autonomous, ReportThenAct, Minimal(⊆Autonomous)}
Strategy:          "When a different approach looks better than the original plan?" → {ProposeThenChoose(⊆ReportThenAct), SwitchAutonomously(⊆Autonomous)}
External:          "When git push or PR creation is needed?" → {Autonomous, AlwaysAsk(⊆AskBefore)}
(Each domain has refinement questions — hybrid question tree)

── SCENARIO TEMPLATES (team extension) ──
TeamCoordination:  "When agents' findings contradict?" → {Autonomous(resolve), ReportThenAct, AskBefore}
ScopeCreep:        "When agent discovers work outside its focus?" → {Autonomous(extend), ReportThenAct, Halt}

── PHASE TRANSITIONS ──
Phase 0:  T → detect(T) → Ctx → Q[AskUserQuestion](propose_mode(Ctx)) → EntryMode  -- mode selection [Tool]
  Single(Ctx) ∧ ¬team(Ctx) → skip (delegation unambiguous; no DC produced)
  propose_mode(Ctx):
    team_active(Ctx)            → present(TeamAugment, TeamRestructure, Solo)  -- situation-dependent; no fixed default
    ¬team(Ctx) ∧ Multi(Ctx)    → propose Solo

Phase 1:  (mode-dependent)                                         -- structure + decomposition
  Solo:         T → decompose(T) → {Dᵢ}                            -- decomposition via Read/Grep
  TeamAugment:  T → inherit(Ctx.team) → WHO[AskUserQuestion](keep/add?) →
                  add? → propose_roles(T, epistemic) → Q[AskUserQuestion](confirm/add/remove) → TeamStructure
                  → decompose(T) → {Dᵢ}                            [Tool]
  TeamRestructure: restructure[AskUserQuestion](T, Ctx.team) → |retain|=0 → terminate (full removal = no team to calibrate)  [Tool]
  TeamRestructure: restructure[AskUserQuestion](T, Ctx.team) → |retain|=|team| ∧ |new|=0 → reset(mode=TeamAugment) → Phase 1 TeamAugment  [Tool]
  TeamRestructure: T → restructure[AskUserQuestion](Ctx.team, T) → T' → decompose(T') → {Dᵢ}  [Tool]

Phase 2:  Dᵢ → template(Dᵢ, mode) → Sₖ → Q[AskUserQuestion](Sₖ) → R  -- scenario interview [Tool]

Phase 3:  R → integrate(R, DC) → DC'                              -- contract update (internal)

Phase 4:  DC' → Q[AskUserQuestion](DC', progress) → approve        -- contract review [Tool]

── LOOP ──
After Phase 0 (mode selection):
  mode_selected → Phase 1
  skip (Single ∧ ¬team) → terminate (delegation unambiguous; no DC produced)

After Phase 3: check uncalibrated domains.
If domains remain: return to Phase 2 (next domain or refinement).
If all calibrated or user Esc key: proceed to Phase 4.

After Phase 4 (contract review):
  approve        → terminate with active DC (approval = authority replacement: DC replaces prior operating contract)
  adjust(who)    → return to Phase 1 (TeamAugment/TeamRestructure only; unavailable in Solo)
  adjust(domain) → return to Phase 2
  withdraw       → terminate; partial DC applies to calibrated domains

── RECALIBRATION ──
recalibrate(DC, T') = new_domain_activated(T') ∨ stakes_escalated(T') ∨ team_topology_changed(T')
stakes_escalated(T') ≡ stakes(T') = High ∧ stakes(T) ∈ {Low, Med}
  -- Low→Med: no recalibration (interruption minimization)
  -- Low/Med→High: recalibration triggered

── WILDCARD ──
wildcard(history) = variance_detected(history) → +1 refinement question
variance_detected(h) ≡ ∃(Dᵢ, Sₖ, R₁), (Dᵢ, Sₖ', R₂) ∈ h : R₁ ≠ R₂ within same domain
|questions| ≤ 12 (Solo: 9, Team: 12)

── TOOL GROUNDING ──
Phase 0 Q   (extern)    → AskUserQuestion (mode selection: TeamAugment/TeamRestructure/Solo)
Phase 1 WHO (extern)    → AskUserQuestion (team structure: keep/add; add → propose epistemic roles → confirm/add/remove)  -- TeamAugment
Phase 1 restructure (extern) → AskUserQuestion (team restructure: retain/remove/add + WHO confirmation)  -- TeamRestructure only
Phase 1     (detect)    → Read, Grep (task analysis for decomposition)
Phase 2 Q   (extern)    → AskUserQuestion (mandatory; Esc key → loop termination at LOOP level, not a Response)
Phase 3     (state)     → Internal DelegationContract update
Phase 4 Q   (extern)    → AskUserQuestion (contract review + approval; includes withdraw option for graceful exit with partial DC)
inherit     (state)     → Read (team config: ~/.claude/teams/{name}/config.json)  -- TeamAugment

── MODE STATE ──
Λ = { phase: Phase, T: TaskScope, mode: EntryMode,
      ctx: DetectedContext, domains: Set(ActionDomain),
      calibrated: Set(ActionDomain), skipped: Set(ActionDomain),
      contract: DelegationContract, who_confirmed: Bool,
      history: List<(Dᵢ, Sₖ, R)>, active: Bool,
      team: Option(TeamRef) }
         -- calibrated ∪ skipped ⊆ domains; calibrated ∩ skipped = ∅
         -- who_confirmed: Solo → true (implicit); TeamAugment/TeamRestructure → set at Phase 1
         -- team: ctx.team is Phase 0 snapshot; team is live reference (inherited for TeamAugment, restructured for TeamRestructure)

Execution context detected:

[Context summary: active team / no team, lens presence, complexity]

Options:
1. **TeamAugment** — keep current team, or add analytical/review perspectives (epistemic only)
2. **TeamRestructure** — adjust team membership, then calibrate (peer review, role change, additional perspectives)
3. **Solo** — single-agent execution (protocol composition, different approach)

Current team: {team members and their perspectives}

Options:
1. **Keep as-is** — retain current structure for execution
2. **Add perspective(s)** — AI suggests additional analytical/review roles; you confirm/add/remove

For this task, I'd like to calibrate how I should handle [domain]:

[Concrete scenario description relevant to the actual task]

Options:
1. **[Autonomy level A]** — [what this means in practice]
2. **[Autonomy level B]** — [what this means in practice]
3. **[Autonomy level C]** — [if applicable]

Here's the delegation contract for this task:

**Autonomous** (I'll proceed without asking):
- [list of calibrated autonomous actions]

**Report then act** (I'll tell you what I'm doing, then proceed):
- [list of report-then-act actions]

**Ask before** (I'll ask for permission first):
- [list of ask-before actions]

**Halt conditions** (I'll stop and escalate):
- [list of halt conditions]

**Skipped** (not applicable to this task):
- [list of domains from Λ.skipped, if any]

**Defaults** (uncalibrated domains default):
- Exploration: autonomous (read-only, inherently safe)
- Others: ask-before

Options:
1. **Approve** — apply this contract
2. **Adjust** — I'd like to change something
3. **withdraw** — exit with partial contract (calibrated domains apply, uncalibrated use defaults)

Here's the delegation contract for this task:

**Team Structure** (WHO):
- [role assignments]

**Autonomous** (proceed without asking):
- [list of calibrated autonomous actions]

**Report then act** / **Ask before** / **Halt conditions**:
- [as in Solo format]

**Authority transition**:
Approval replaces the team's prior operating contract with this DelegationContract.

Options:
1. **Approve** — apply this contract (authority replacement)
2. **Adjust** — I'd like to change something
3. **withdraw** — exit with partial contract (calibrated domains apply, uncalibrated use defaults)