attend

What this skill does

# Prosoche Protocol

Route upstream epistemic deficits and evaluate execution-time risks during AI operations through upstream scanning, task materialization, risk classification, and delegation. Type: `(ExecutionBlind, User, EVALUATE, ExecutionContext) → SituatedExecution`.

## Definition

**Prosoche** (προσοχή): A dialogical act of sustained attention to execution risk — from the Stoic practice of self-aware engagement — resolving execution blindness by first scanning for upstream epistemic deficits and routing to appropriate protocols, then materializing intent into tasks, classifying each for risk signals, delegating low-risk tasks to a subagent executor, and gating elevated-risk actions through evidence-grounded checkpoints for user judgment.

```
── FLOW ──
Prosoche(C) →
  UpstreamScan(C, Resolved) → D[] →
    D[] = ∅ → Sub-A
    D[] ≠ ∅ → Qc(D[]) → Stop → RouteDecision →
      Proceed  → Sub-A
      Route(P) → suspend(Λ) → execute(P)[Skill] → restore(Λ) → re-scan(Resolved ∪ {P})
      Other(P) → resolve Qc(P) → Stop → suspend(Λ) → execute(P)[Skill] → restore(Λ) → re-scan(Resolved ∪ {P, d.deficit})
  → Materialize(C) → T[] →
  Team?(C) → TeamCoord Qc → Stop → TeamStructure →
  ∀t∈T: Classify(t.E) → p →
    p=Low:      delegate(t) → executor(t.E) → { complete(t) | GATE_DETECTED(Fi) → Phase 1 }
    p=Elevated: Eval(t.E) → Fi → Qc(Fi, evidence) → Stop → J → A(J, t, Σ) → Σ'
  → |{t : t.status ∉ {completed, halted}}| = 0 →
  withdraw? | deactivate

── MORPHISM ──
ExecutionContext
  → route_upstream(deficits)              -- pre-execution upstream protocol routing
  → materialize(intent)                  -- intent to concrete task list
  → coordinate(team?)                    -- optional team structure for delegation routing
  → classify(evidence)                   -- per-task risk signal detection
  → ClassifiedActions                    -- p=Low: delegate (no further transformation)
  → evaluate(elevated_risks)             -- evidence gathering for Gate/Advisory signals
  → surface(findings)                    -- present risk findings for user judgment
  → adapt(judgment)                      -- integrate user decision into execution state
  → SituatedExecution
requires: user_initiated(C)               -- user declares execution intent via /attend
deficit:  ExecutionBlind                  -- activation precondition (Layer 1)
preserves: T[]                            -- tasks read-only after materialization; morphism produces judgments in Σ
invariant: Attention over Automation

── TYPES ──
C              = ExecutionContext { tasks: List(Task), prior: ProtocolOutput?, args: String?,
                                    team: Option(TeamRef) }
Materialize    = C → List(Task) [Tool: TaskCreate, TaskList]
Task           = { id: TaskId, E: ExecutionAction, status: ∈ {pending, in_progress, completed, halted} }
                                                        -- in_progress: set by executor on start
E              = ExecutionAction (pending tool call or action chain)
ProtocolOutput = prior protocol's converged output in current session
Classify       = Risk classification: E → p (silent signal detection; failure → p = Elevated)
p              = RiskLevel ∈ {Low, Elevated}
ClassifiedActions = { t: Task, p: RiskLevel }[]     -- per-task classification result; intermediate checkpoint
delegate       = t → Agent(executor) → { complete(t) | GATE_DETECTED(Fi) → Phase 1 }
Eval           = Risk evaluation: E → Set(Finding)
Finding        = { signal: Signal, evidence: String, severity: ∈ {Advisory, Gate}, action_description: String }
Signal         ∈ {Irreversibility, HumanCommunication, ExternalMutation, SecurityBoundary, PromptInjection, ScopeEscalation} ∪ Emergent(Signal)
Q              = Checkpoint question (via Constitution interaction)
J              = Judgment ∈ {Approve, Modify(direction), Dismiss, Halt, Withdraw}
A              = Adaptation: J × Task × Σ → Σ'                   -- judgment integration function
Σ              = { assessed: N, surfaced: N, halted: Set(String),             -- action identifier (e.g., "git push origin/main")
                   granularity: Granularity, session_approvals: Map(Pattern, Unit) }  -- Unit presence = approved for session
Granularity    ∈ {Meso, Micro}                                 -- Meso: per task; Micro: per tool call within task
Pattern        = (tool_name, target, env_context)
                 -- tool_name: tool or command (e.g., "pulumi up", "git push")
                 -- target: specific resource (e.g., branch name, file path, stack name)
                 -- env_context: environment qualifier inferred from arguments/config (e.g., "dev", "prod")
                 -- env_context inference failure → env_context = "unknown"; "unknown" never matches cached patterns
                 -- match: all 3 components must match for cache hit

-- Absorbed from Epitrope (team coordination):
TeamRef        = { name: String, members: Set(AgentRef), tasks: Set(TaskId) }
AgentRef       = { name: String, type: String, perspective: Option(String) }
TeamStructure  ∈ {Solo, Augmented(TeamRef, Set(AgentRole)), Restructured(TeamRef, Set(AgentRole), Set(AgentRef))}
AgentRole      = { name: String, type: String, focus: String }

Phase          ∈ {-1, 0, 1, 2, 3}
SituatedExecution = Σ' where (∀ t ∈ T: situated(t)) ∨ user_withdraw ∨ user_esc

-- Sub-A0 (Upstream Protocol Router):
D                = Set(DetectedDeficit)                             -- unresolved upstream deficits
DetectedDeficit  = { protocol: ProtocolId, deficit: DeficitCondition, evidence: String }
UpstreamScan     = (C, Resolved) → { d ∈ Detect(C) : d.protocol ∉ Resolved ∧ d.deficit ∉ Resolved } = D
RouteDecision    = Proceed | Route(ProtocolId) | Other(ProtocolId)
Resolved         = Set(ProtocolId ∪ DeficitCondition) -- protocols executed + deficits addressed via Other
SuspendState     = { resolved: Resolved, iteration: N }
Fired            = Resolved ≠ ∅ ∨ chose(Proceed)  -- Sub-A0 produced non-trivial interaction
ProtocolId       ∈ {elicit, bound, inquire, frame, ground}
DeficitCondition ∈ {IntentMisarticulated, GoalIndeterminate, BoundaryUndefined,
                    ContextInsufficient, FrameworkAbsent, MappingUncertain}

── MATERIALIZATION ROUTING ──
Materialize(C) routes on context richness:
  C.tasks ≠ ∅ ∧ ¬C.prior  → adopt(C.tasks), resume execution
  C.tasks ≠ ∅ ∧ C.prior   → conflict Qc: resume(C.tasks) | refresh(C.prior) | merge
  C.tasks = ∅ ∧ C.prior   → create(T[], C.prior), confirm_boundary 1x [Tool]
                            -- cross-protocol boundary: prior protocol's output → Prosoche's task list
                            -- Cognitive Partnership Move (Extension/Constitution) test: this action crosses protocol boundary (Constitution)
  C.tasks = ∅ ∧ ¬C.prior ∧ Fired  → create(T[], C.args), auto_proceed
                                    -- Sub-A0 interaction verified context
  C.tasks = ∅ ∧ ¬C.prior ∧ ¬Fired → create(T[], C.args), confirm 1x [Tool]
                                    -- transparent cold start: no upstream or prior verification

Context detection:
  C.tasks = TaskList content at invocation time (named persistent list: attend-{context})
  C.prior = protocol chain's accumulated output in current session
           -- longer chains (e.g., Aitesis → Prosoche) = more verified intent
           -- longer chains justify confirm_boundary's lighter touch (1 confirmation vs cold-start's full verify)
  ¬C.prior ≡ no protocol invoked before /attend
Design principles:
  confirmation count ∝ 1/context richness, bounded by Cognitive Partnership Move (Extension/Constitution): tasks→0(adopt), prior→1(boundary), conflict→1(resolve), neither+Fired→0(Sub-A0 verified), neither+¬Fired→1(confirm)
  dual safety net with conditional upstream: Sub-A0 verifies "upstream readiness" (when Fired), Materialize verifies "what" (intent, when ¬Fired ∧ ¬C.prior), Phase 0 Classify verifies "how" (risk) — independent checks

── PHASE TRANSITIONS ──
Phase -1: