frame

Prothesis Protocol

Resolve absent frameworks by placing available epistemic perspectives before the user for lens selection, then for each selected lens computing the substrate it needs and handing the lens↔substrate pairs off — without arranging, isolating, executing, or synthesizing. Type: (FrameworkAbsent, AI, DESIGN, Inquiry) → FramedInquiry.

Definition

Prothesis (πρόθεσις): A dialogical act of presenting available epistemic perspectives as options when the appropriate framework is absent, enabling selection before any perspective-requiring cognition, then for each selected lens computing the substrate that lens needs — an authoritative substrate_need (the abstract persona/capability) plus advisory binding_hints (an enumerated candidate shortlist) — and handing the framed object off. The framed object is a detailed lens (when a single lens, or no specialized substrate beyond general-purpose is needed → LensReturn) or a set of lens↔substrate pairs (when ≥2 lenses are present and at least one carries a specialized substrate need → SubstrateCorrespondence). frame is the lens-formation tool: it yields the analysis object (the lens) and its substrate need + channel need, nudges /conduct for the isolation + arrangement + synthesis apparatus, and ends its own action at handoff — a boundary on what frame does, not a halt of the turn. Isolating the perspectives, arranging them — the order, independence, reconciliation, termination, and routing — and integrating their results is /conduct's to design (reached via the nudge) and the substrate's to execute (spawn, isolated analysis, reconcile, synthesize). frame neither realizes isolation nor synthesizes a multi-perspective result in its own context: convergence is claimable only by the isolated substrate that ran the lenses, which frame neither performs nor asserts.

── FLOW ──
Prothesis(U) → Q1(MB(U)) → J_mb → [confirm: MBᵥ | modify(field): MB' → re-present Q1(MB') → J_mb (loop until confirm)] → G(MBᵥ) → C → {P₁...Pₙ}(C, MBᵥ) → Sc({P₁...Pₙ}, Pᵦ) → Pₛ → LensEstablished →
  bind_substrate(Pₛ) → {⟨pᵢ, substrate_needᵢ, binding_hintsᵢ, channel_needᵢ⟩} →
  [single lens ∨ no specialized substrate: package(detailed lens) → LensReturn] |
  [≥2 lenses with at least one specialized substrate need: pair(lens ↔ substrate_need + binding_hints) ⊕ nudge(ConductRef) → SubstrateCorrespondence] →
  converge(trace) → handoff(FramedInquiry) → seam → END(morphism)
  -- END(morphism) = frame's own action ends: it arranges, isolates, executes and synthesizes NOTHING. This bounds what frame does; it does not halt the turn — two different boundaries, and only the first is frame's to declare
  -- seam = the next move proceeds under the source that SETTLED it, in precedence: an arrangement the invoking context has already settled — a user-declared chain naming the next protocol, or a caller carrying its own arrangement for these lenses — settles it first; failing that, the ConductRef this file declares, borne by every SubstrateCorrespondence handoff, settles it and the seam proceeds to /conduct. ConductRef fills an arrangement still UNDERDETERMINED — /conduct's own activation precondition — and never overrides one already fixed. Absent both — the LensReturn branch, which carries no ConductRef — the handoff is the last move
  -- ConductRef = the /conduct nudge that carries isolation + arrangement + reconciliation + synthesis; frame forms lenses and hands them off, never realizing isolation or asserting convergence

── MORPHISM ──
Inquiry
  → confirm(mission_brief)              -- validate inquiry framing with user
  → gather(context)                     -- targeted context acquisition guided by MBᵥ
  → propose(perspectives)               -- generate distinct analytical lenses from context
  → select(perspectives)                -- user chooses lenses via Cognitive Partnership Move (Constitution)
  → LensEstablished                     -- the analysis object (lens)
  → bind_substrate(perspectives)        -- per lens, compute substrate_need (authoritative abstract persona/capability) + binding_hints (advisory candidate shortlist) + channel_need; NEVER binds a concrete agent
  → discriminate(substrate_specialization_need) -- single lens ∨ no specialized substrate beyond general-purpose → LensReturn; ≥2 lenses with at least one specialized substrate need → SubstrateCorrespondence
  → handoff(framed_inquiry)             -- emit the framed object (detailed lens(es), or lens↔substrate pairs ⊕ /conduct nudge), then cross the seam — frame does NOT realize isolation, arrange, execute, or synthesize; the isolation + arrangement + synthesis apparatus is /conduct's to design (via the nudge) and the isolated substrate's to run
  → FramedInquiry
requires: framework_absent(U)             -- runtime checkpoint (Phase 0)
deficit:  FrameworkAbsent                  -- activation precondition (Layer 1/2)
preserves: U                               -- original request read-only
invariant: Placement over Prescription; substrate-invariance (declares the NEED, never binds a concrete agent); no inline synthesis and no inline isolation (convergence claimable only by the isolated substrate, which frame neither performs nor asserts)

── TYPES ──
U      = Underspecified request (purpose clear, approach unclear)
MB     = MissionBrief(U): { inquiry_intent, expected_deliverable, scope_constraint }  -- AI-inferred from U
Q1     : MB → J_mb                               -- extern (Mission Brief confirmation/modification; the sole Phase 0 interaction — no mode question); answer type is J_mb, not MBᵥ directly
MBᵥ    = Verified MissionBrief (user-confirmed)  -- DERIVED when J_mb = confirm; on J_mb = modify(field), Q1 re-presents over the revised MB' until confirm yields MBᵥ
G      = Gather: MBᵥ → C                       -- targeted context acquisition (guided by MBᵥ)
C      = Context (information for perspective formulation)
Pᵦ     = Pre-confirmed base perspectives (user-supplied in U or at the Z zero-result surfacing; auto-included in Pₛ)
{P₁...Pₙ}(C, MBᵥ) = AI-proposed novel perspectives (Pᵢ ∉ Pᵦ)
Sc     = Selection: ({P₁...Pₙ}, Pᵦ) → Pₛ      -- extern (user choice; Pᵦ auto-included)
Pₛ     = Selected perspectives (Pₛ = Pᵦ ∪ the user's selection from {P₁...Pₙ}, |Pₛ| ≥ 1)
         -- the framed object's form is decided at Phase 3 by substrate specialization need, not by lens count (see FramedInquiry)
Z      = ZeroCandidate: {P₁...Pₙ} = ∅ ∧ Pᵦ = ∅   -- Phase 2 guard: no candidate frameworks to place; surfaced as a finding (Constitution); responses: modify(field) (the J_mb constructor) | supply(Pᵦ') (perspective supply, typed via Pᵦ enrichment) — no FramedInquiry is emitted from this branch
LensEstablished = Pₛ where lens selection complete  -- the analysis object; Phase 3 binds each lens's substrate and discriminates the output by substrate specialization need
-- framed object: a detailed lens (LensReturn) or lens↔substrate pairs (SubstrateCorrespondence). frame forms the OBJECT plus its substrate NEED and hands it off; the ARRANGEMENT over multiple objects — and their isolation, reconciliation, and synthesis — is NOT produced here: it is /conduct's to design (referenced by ConductRef, carried as the nudge) and the substrate's to run --
SubstrateNeed = per-lens AUTHORITATIVE abstract persona/capability the lens requires (what kind of analyst/agent must run this lens) -- declares the NEED only; names no concrete agent (substrate-invariance). Extends the ChannelNeed pattern from channel to persona/capability
BindingHints  = per-lens ADVISORY, ENUMERATED shortlist of candidate substrates that could fulfill the SubstrateNeed (specific agent personas / subagent types; PREFER skill-bundled agents when they exist) -- NON-binding. Rationale: unless an agent is bundled with the skill, hosts rarely recognize available agents as substrates and default to general-purpose; the enumerated hint list makes specialized binding actually happen. Hints being advisory, substrate-invariance still holds
ConductRef = the /conduct nudge that accompanies every SubstrateCorrespondence handoff (the prothesis→hyphegesis advisory edge): it routes the isolation + arrangement (order, independence, reconciliation, termination, routing) + synthesis apparatus to /conduct, which designs it, and the isolated substrate, which runs it — frame names the reference, never realizing isolation, arranging, or synthesizing
ChannelNeed = per-perspective evidence-channel need (code/workspace | canonical external source | instrumentation | user-tacit)  -- a channel-level signal for substrate tool authorization, no concrete provider named (utility-agnostic)
PerspectiveDirective = the per-lens output contract that briefs each perspective: { epistemic_contribution, framework_analysis, horizon_limits, assessment } over MBᵥ + the verbatim question; part of forming the lens (per-lens, not cross-lens). The CROSS-lens reconciliation/synthesis machinery is NOT here — it is /conduct's. Carries no spawn/peer mechanics (substrate-owned)
LensPair = ⟨lens: pᵢ, substrate_need: SubstrateNeed, binding_hints: BindingHints, per_perspective_directive: PerspectiveDirective, channel_need: ChannelNeed⟩  -- one lens bound to the substrate it needs (need authoritative, hints advisory)
LensReturn = { lenses: { ⟨pᵢ, per_perspective_directive: PerspectiveDirective, channel_need: ChannelNeed⟩ } }  -- single lens, OR ≥2 lenses with NO specialized substrate beyond general-purpose (substrate_need is general-purpose by definition): each detailed lens returned directly WITH its own per-lens directive and channel_need (the per-lens tool-authorization signal Phase 3 computes for every lens — preserving the lens↔channel mapping even with multiple lenses). NO synthesis, NO convergence claim, NO isolated handoff
SubstrateCorrespondence = { pairs: {LensPair}, arrangement: ConductRef }  -- ≥2 lenses with at least one specialized substrate need: lens↔(substrate_need + binding_hints + per_perspective_directive + channel_need) pairs, handed off with the /conduct nudge (ConductRef) that carries the isolation + arrangement + reconciliation + synthesis concern. frame forms the pairs and STOPS — it does NOT realize isolation, arrange, execute, or synthesize
FramedInquiry = inj₁(LensReturn where single lens ∨ no specialized substrate) ⊕
                inj₂(SubstrateCorrespondence where ≥2 lenses with at least one specialized substrate need)
        -- coproduct discriminated by SUBSTRATE SPECIALIZATION NEED (NOT a user-chosen mode): inj₁ → LensReturn (detailed lens(es) returned, no isolation handoff); inj₂ → SubstrateCorrespondence (lens↔substrate pairs handed off ⊕ /conduct nudge). NEITHER is executed by frame; isolation/convergence/synthesis is claimable only by a substrate that ran the lenses in genuine isolation, which frame neither performs nor asserts. FramedInquiry itself carries lenses and substrate pairs, never direction candidates — any direction alternatives that later become recognizable emerge downstream, from lens work executed on the framed inquiry, never from frame's own output.
J_mb   = MissionBriefRouting ∈ {confirm, modify(field)}  -- Phase 0 routing decision

── U-BINDING ──
bind(U) = explicit_arg ∪ colocated_expr ∪ prev_user_turn ∪ ai_identified_request
Priority: explicit_arg > colocated_expr > prev_user_turn > ai_identified_request

/frame "text"                → U = "text"
/frame (alone)               → U = previous user message
"investigate... frame"       → U = text before trigger
AI-detected trigger           → U = request AI identified

Edge cases:
- Re-invoke: If Pₛ exists in context, offer as Pᵦ for new invocation

── PHASE TRANSITIONS ──
Phase 0:  U → MB(U) → Q1(MB) → Stop → J_mb → [confirm: derive MBᵥ | modify(field): MB' → re-present Q1(MB') → Stop → J_mb]   -- Mission Brief confirmation ONLY (no mode question); MBᵥ is derived on confirm, not Q1's direct return [Tool]
Phase 1:  MBᵥ → G(MBᵥ) → C                                      -- targeted context acquisition
Phase 2:  (C, MBᵥ) → Sc({P₁...Pₙ}(C, MBᵥ), Pᵦ) → Stop → Pₛ → LensEstablished  -- perspective selection [Tool]; single lens is valid; on Z (zero candidates) surface the finding → Stop → route per LOOP (modify | Pᵦ' supply)
Phase 3:  LensEstablished → bind_substrate(Pₛ) → discriminate(substrate_specialization_need) → [single lens ∨ no specialized substrate: LensReturn | ≥2 lenses with at least one specialized substrate need: SubstrateCorrespondence(lens↔substrate pairs) ⊕ nudge(ConductRef)] → converge(transformation trace) → handoff(FramedInquiry) → seam → END(morphism)  -- bind each lens's substrate, discriminate by substrate specialization need, emit the framed object as the terminal relay with the /conduct nudge, then end frame's own action (no gate of frame's own, no dispatch by frame, NO isolation, NO synthesis; isolation + arrangement + synthesis is /conduct's to design and the isolated substrate's to run downstream). The seam then carries the settled next move wherever the handoff names one — an arrangement the invoking context already settled where there is one, else the ConductRef on the SubstrateCorrespondence branch — under that protocol's own gates

── LOOP ──
After Phase 0 (Mission Brief confirmation only):
  J_mb = confirm       → proceed to Phase 1 with MBᵥ
  J_mb = modify(field) → re-present Q1(MB') → Stop → J_mb (loop until confirm derives MBᵥ)

During Phase 2 (Perspective Placement):
  Z ({P₁...Pₙ} = ∅ ∧ Pᵦ = ∅) → present the zero-result finding with reasoning → Stop:
    modify(field) → re-present Q1(MB') → Stop → J_mb (loop until confirm derives MBᵥ) → re-enter Phase 1 (re-gather) → Phase 2
    supply(Pᵦ')   → Pᵦ := Pᵦ' (auto-included) → re-present Sc with ≥ 1 novel proposal
  -- a single selected lens is valid (→ LensReturn); no two-lens minimum and no under-minimum recovery (there is no mode to satisfy)
  -- no FramedInquiry is emitted from Z; the result equation is unchanged (FramedInquiry requires LensEstablished)

During Phase 3 (Bind Substrate & Handoff):
  bind_substrate(Pₛ) → for each pᵢ ∈ Pₛ compute ⟨substrate_needᵢ (authoritative abstract persona/capability), binding_hintsᵢ (advisory enumerated candidate shortlist; PREFER skill-bundled agents), channel_needᵢ⟩ → never bind a concrete agent
  discriminate(substrate_specialization_need):
    single lens (|Pₛ| = 1) ∨ no specialized substrate beyond general-purpose → package the detailed lens(es): emit FramedInquiry = inj₁(LensReturn), hand off; frame's own action ends there, and this branch carries no ConductRef for the seam to proceed to. NO synthesis, NO convergence claim, NO isolated handoff.
    ≥2 lenses with at least one specialized substrate need → pair each lens with ⟨substrate_need + binding_hints + per-perspective directive + channel-need⟩ → emit FramedInquiry = inj₂(SubstrateCorrespondence) with the /conduct nudge (ConductRef), hand off the lens↔substrate pairs; frame's own action ends there and the seam proceeds to /conduct on that ConductRef — unless the invoking context has already settled the arrangement, in which case the seam proceeds under that instead. frame does NOT realize isolation, arrange, execute, or synthesize.
  -- handoff is the completeness boundary: frame records the handoff and its own action ends there — a boundary on frame's morphism, not a halt of the turn. Where the handoff names a settling source the seam carries the next move directly, under that protocol's own gates: an arrangement the invoking context already settled where there is one, and otherwise the ConductRef every SubstrateCorrespondence handoff bears. frame does NOT realize isolation — the isolated execution arrangement (isolation, reconciliation/dialogue, synthesis) is /conduct's to design (the /conduct nudge accompanies every SubstrateCorrespondence handoff) and the substrate's to run (an agent team, a dynamic-workflow, isolated subagents, or plan-mode). Convergence is claimable only by the isolated substrate that ran the lenses, which frame neither performs nor asserts.

Continue until convergence: FramedInquiry handed off (detailed lens(es) via LensReturn, or lens↔substrate pairs via SubstrateCorrespondence).

Convergence evidence: At handoff, present the transformation trace — for each p ∈ Pₛ, show (FrameworkAbsent → p's contribution as a lens of the framed object). SubstrateCorrespondence additionally surfaces each lens's substrate_need + binding_hints + channel-need and the /conduct nudge (which carries the isolation + arrangement + synthesis apparatus) as relay text. Convergence-of-the-framing is demonstrated, not asserted — frame never asserts a multi-perspective convergence of the inquiry's findings (that is the isolated substrate's to claim, under the arrangement /conduct designs).

── BOUNDARY ──
discriminate  = purpose: coproduct selection by substrate specialization need (relay; entropy→0 once Pₛ and substrate needs are fixed; PerspectiveDirective wording is generated, but its contract shape is fixed by the template)

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 MB_from_arg (extension)  → TextPresent+Proceed (when user_invoked ∧ explicit_arg(U); Q1=confirm default; Phase 2 Sc remains constitution as downstream correction opportunity)
Phase 0 Q1 (constitution)        → present (Mission Brief confirmation ONLY — no mode question; when no explicit_arg)
G (observe)                      → artifact read, artifact search (meta-scope context acquisition guided by MBᵥ to identify relevant perspectives; not passed to the substrate — each perspective independently collects object-scope evidence through its own lens at execution time)
Sc (constitution)                → present (mandatory; multiSelect: true; lens selection is epistemic choice; single lens valid)
Phase 2 Z zero_result (constitution) → present (zero-candidate finding + reasoning; responses: modify(field) | supply(Pᵦ') → Pᵦ enrichment)
Phase 3 bind_substrate (sense)   → Internal operation (per-lens substrate_need (authoritative abstract persona/capability) + binding_hints (advisory candidate shortlist; PREFER skill-bundled agents) + channel_need; relay — no external tool, no user judgment beyond Pₛ; frame declares the NEED, never binds a concrete agent)
Phase 3 discriminate (sense)     → Internal operation (coproduct by substrate specialization need: single lens ∨ no specialized substrate → LensReturn = inj₁ FramedInquiry; ≥2 lenses with at least one specialized substrate need → SubstrateCorrespondence (lens↔substrate pairs ⊕ per-perspective directive ⊕ channel-need) with the /conduct nudge = inj₂ FramedInquiry)
Phase 3 converge (extension)     → TextPresent+Proceed (convergence-of-framing evidence trace: per-perspective contribution; SubstrateCorrespondence additionally surfaces each lens's substrate_need + binding_hints + channel-need + the /conduct nudge; NO synthesis of findings, NO isolation realized)
Phase 3 handoff (extension)      → TextPresent+Proceed (emit the FramedInquiry — detailed lens(es) or lens↔substrate pairs ⊕ /conduct nudge — as the terminal relay; frame's own morphism ends here and it does NOT realize isolation, arrange, execute, or synthesize — it does NOT spawn or call delegate. Ending the morphism is not halting the turn: what proceeds is the seam below, and where the handoff names no settling source — the LensReturn branch, which carries no ConductRef — the seam has nothing to proceed to and the handoff is the last move. The isolation + arrangement + synthesis apparatus is /conduct's to design (via the nudge) and the substrate's to run; when the substrate is the main session (the default) it consumes the framed object, when isolated executors are elected that dispatch is the substrate's action, not frame's morphism)
Λ (track)                        → Internal state update (the problem-to-solve and the framing shifts are what LEAVES this protocol: they ride in the FramedInquiry the Phase 3 handoff emits, and per-phase bookkeeping stays in session and does not leave at all. No separate durable entry is written here — it would be a second copy of what the handoff already carries, and a copy can drift from the thing it copies while still reading as authoritative)
seam (extension)                 → TextPresent+Proceed (fires at deactivation/handoff: proceed directly to the next move, citing the source that SETTLED it; every Constitution gate inside this protocol and inside the next protocol fires unchanged. Precedence: an arrangement the invoking context has ALREADY settled — a user-declared chain naming the next protocol, or a caller that carries its own arrangement for these lenses and says so — settles it first and the seam proceeds under that; failing that, the composition edge this SKILL.md declares — the ConductRef nudge accompanying a SubstrateCorrespondence handoff — settles it and the seam proceeds to /conduct. ConductRef fills an arrangement that is still UNDERDETERMINED — which is /conduct's own activation precondition — and never overrides one already fixed: a caller whose order, independence, reconciliation, termination and routing are all settled leaves /conduct nothing to determine, so routing there would ask a protocol to re-open a closed question rather than answer an open one, and its own warrant would relay back)
-- Substrate realization: the framed object is substrate-invariant; an agent-team, a dynamic-workflow, isolated subagents, and plan-mode are PEER substrates that may execute it (the main session is a peer substrate only as an orchestrator that elects isolated executors, never isolating the lenses inline in its own context) — the substrate (or /conduct at arrangement time) owns the concrete execution tools and realizes isolation, not frame. frame declares the per-lens substrate_need (authoritative) and surfaces binding_hints (advisory candidate substrates), the per-perspective channel-need, and the /conduct nudge as handoff annotations — it NEVER binds a concrete agent and NEVER realizes isolation. Isolation + arrangement + reconciliation + synthesis is /conduct's to design (via the nudge) and the substrate's to run. Topology→substrate feasibility (e.g. a dialectical arrangement requires persistent addressable peers; an independent-aggregate ⨾ adversarial pass over a static aggregate is realizable by a stateless pipeline) is the substrate's to enforce — surfaced by /conduct at arrangement time and by the substrate at execution time, never bound by frame. The (constitution)/(extension) markers above are the authoritative axis.

── CATEGORICAL NOTE ──
frame forms analysis OBJECTS (lenses) plus each object's substrate NEED; /conduct is the ARRANGEMENT FUNCTOR over objects, generic in object type (objects = perspectives → multi-lens inquiry arrangement; objects = protocols → protocol-chain arrangement — the same functor, the same topology algebra). frame's framed object is a detailed lens (LensReturn) or lens↔substrate pairs (SubstrateCorrespondence), never an arrangement: the arrangement — together with the isolation and synthesis it governs — is the functor's action, attributed to /conduct and reached via the ConductRef nudge that accompanies every SubstrateCorrespondence handoff — ahead of which an invoking context that already carries its own arrangement settles the next move itself, ConductRef being the default for an arrangement still underdetermined rather than an override of one already fixed. frame binds the lens to the substrate it NEEDS (authoritative) with advisory binding_hints, but never to a concrete agent — substrate-invariance holds. Isolation and synthesis are NOT frame's: convergence/divergence/synthesis-basis are produced by an isolated substrate that ran the lenses (under the arrangement /conduct designs), never realized or asserted inside frame's own context — that belongs to the executed layer, outside frame's verification scope by design.

── MODE STATE ──
Λ = { phase: Phase, mission_brief: Option(MBᵥ), perspectives: Option(Pₛ), framed_output: Option(FramedInquiry), active: Bool }
Phase ∈ {0, 1, 2, 3}
-- no mode field (frame has no user-chosen mode): the framed output is discriminated at Phase 3 by substrate specialization need (LensReturn vs SubstrateCorrespondence), not by a Phase 0 choice. The section name is the cross-protocol structural-state slot, not a "mode" toggle.

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). Dimension resolution emergent via session context.