| name | goal |
| description | [Deprecated — use /elicit (Euporia) for axis-emergent reverse induction] Co-construct defined goals from vague intent. Builds a GoalContract when neither party has a clear end state. Type: (GoalIndeterminate, AI, CO-CONSTRUCT, VagueGoal) → DefinedEndState. Alias: Telos(τέλος). |
Telos Protocol
Co-construct defined end states from vague goals through AI-proposed, user-shaped dialogue. Type: (GoalIndeterminate, AI, CO-CONSTRUCT, VagueGoal) → DefinedEndState.
Definition
Telos (τέλος): A dialogical act of co-constructing a defined end state from a vague goal, where AI proposes concrete candidates and the user shapes them through structured accept, modify, or reject responses.
── FLOW ──
G → Gᵥ → detect(Gᵥ) → Dd → Dₐ → Dₛ → P → A → C' → (loop until sufficient)
── MORPHISM ──
VagueGoal
→ recognize(goal, indeterminacy) -- confirm goal needs definition
→ detect(dimensions, evidence) -- surface indeterminate dimensions
→ propose(dimension, candidate) -- generate concrete falsifiable proposal
→ integrate(response, contract) -- shape contract from user response
→ approve(contract) -- verify sufficiency of GoalContract
→ DefinedEndState
requires: goal_indeterminate(G) -- Phase 0 checkpoint (2+ dimensions unspecified)
deficit: GoalIndeterminate -- activation precondition (Layer 1/2)
preserves: G -- read-only throughout; morphism acts on C only
invariant: Construction over Extraction
── TYPES ──
G = User's vague goal (the goal to define)
Gᵥ = Verified vague goal (user-confirmed)
Dd = AI-detected dimensions ⊆ {Outcome, Metric, Boundary, Priority} ∪ Emergent(G)
-- raw detection output, presented as full taxonomy at Phase 1
Dₛ = Selected dimension ∈ {Outcome, Metric, Boundary, Priority} ∪ Emergent
Dₐ = Applicable dimensions = (Dd ∪ {Outcome} ∪ Λ.emergent) \ Λ.excluded
-- initial working set from Phase 1 Extension presentation; mutable via Phase 2 free-response override
-- protocol constraint: Outcome ∉ Λ.excluded → Dₐ ⊇ {Outcome}
P = Proposal (AI-generated concrete candidate)
A = User's response ∈ {Accept, Modify(aspect, direction), Reject, Extend(aspect)}
C = GoalContract { outcome: ?, metric: ?, boundary: ?, priority: ? }
C' = Updated GoalContract after integration
── G-BINDING ──
bind(G) = explicit_arg ∪ colocated_expr ∪ prev_user_turn
Priority: explicit_arg > colocated_expr > prev_user_turn
/goal "text" → G = "text"
"define goal... goal" → G = text before trigger
/goal (alone) → G = previous user message
Edge cases:
- Interrupt: G = original request of interrupted task
- Queued: G = previous message at queue time (fixed)
- Re-invoke: Show prior GoalContract, confirm or restart
── PHASE TRANSITIONS ──
Phase 0: G → recognize(G) → Qc(confirm) → Stop → Gᵥ -- trigger + confirm [Tool]
Phase 1: Gᵥ → detect(Gᵥ) → Dd → TextPresent(extension) → compute(Dₐ) → Dₛ -- dimension detection + full taxonomy presentation [Tool]
Phase 2: Dₛ → propose(Dₛ, context) → P -- AI proposal (sense)
→ Qs(P) → Stop → A -- co-construction [Tool]
Phase 3: A → integrate(A, C) → C' -- contract update (sense)
Phase 4: C' → Qc(C', progress) → Stop → approve -- sufficiency check [Tool]
── LOOP ──
After Phase 3: compute progress(C', Dₐ) where Dₐ reflects current Λ.excluded and Λ.emergent (recomputed each re-entry).
If undefined dimensions remain in Dₐ: return to Phase 1 (next dimension).
On re-entry, detect(Gᵥ) scopes to undefined dimensions in Dₐ; already-defined dimensions are excluded from Dd.
Re-entry is pure Extension (auto-proceed); taxonomy revision remains reachable via Phase 2 free response (adds to Λ.excluded or Λ.emergent, triggering Dₐ recomputation).
If all Dₐ defined: proceed to Phase 4.
User can trigger Phase 4 early at any Phase 1 (early_exit).
Continue until: user approves GoalContract OR user ESC.
Convergence evidence: At Phase 4, present transformation trace — for each d ∈ Dₐ, show (GoalIndeterminate(d) → C'.defined(d)). User approval is the convergence checkpoint (Constitution); the evidence trace enables informed approval.
── CONVERGENCE ──
sufficient(C, Dₐ) = user_approves(C)
progress(C, Dₐ) = |{f ∈ Dₐ | defined(f)}| / |Dₐ|
early_exit = user_declares_sufficient (any progress level)
── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 G_from_arg (extension) → TextPresent+Proceed (when explicit_arg via /goal "text"; proceed with inferred goal seed; Phase 2 Qs free-response override available downstream)
Phase 0 Qc (constitution) → present (goal confirmation + activation approval; when no explicit_arg)
Phase 1 detect (sense) → Internal analysis (dimension detection from Gᵥ)
Phase 1 present (extension) → TextPresent+Proceed (full taxonomy with evidence + falsification + emergent probe + progress display; option-set relay test — Proceed dominates under user-invoked or user-confirmed activation; flows into Phase 2)
Phase 2 P (observe) → Read, Grep (context for proposal generation; fallback: template)
Phase 2 Qs (constitution) → present (mandatory; Accept/Modify/Reject/Extend — user shapes contract; free response overrides taxonomy — emergent add, non-Outcome exclude, redirect; override capability must be disclosed at the Constitution interaction under user authority; Esc key → loop termination at LOOP level, not a Response)
Phase 3 (track) → Internal GoalContract update (no external tool)
Phase 4 Qc (constitution) → present (GoalContract review + approval — final binding decision)
converge (extension) → TextPresent+Proceed (convergence evidence trace; context for Phase 4 Qc GoalContract approval)
── MODE STATE ──
Λ = { phase: Phase, G: Goal, Gᵥ: Goal, detected: Set(Dim), applicable: Set(Dim),
excluded: Set(Dim), emergent: Set(Dim),
contract: GoalContract, history: List<(Dₛ, P, A)>, active: Bool }
-- Constraint: Outcome ∉ excluded (protocol); applicable = (detected ∪ {Outcome} ∪ emergent) \ excluded
── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). graph.json edges preserved. Dimension resolution emergent via session context.
Core Principle
Construction over Extraction: AI proposes concrete candidates; user shapes through structured response options. Neither party holds the complete answer alone.
Epistemic Distinction from Requirements Engineering
Telos is not simplified requirements gathering. Three differentiators:
- Detection with user authority: AI presents full taxonomy assessment as Extension (auto-proceed) with evidence and falsification conditions; user authority is exercised at Phase 2 co-construction Constitution interactions via structured response and free-response override (not elicited by checklist)
- Morphism firing: Activates only when
GoalIndeterminate precondition is recognized — not a mandatory pipeline stage
- Falsifiable proposals: AI proposes specific candidates that can be directly accepted or rejected, surfacing value conflicts and trade-offs (epistemic function) rather than collecting specifications (engineering function)
Distinction from Other Protocols
| Protocol | Initiator | Deficit → Resolution | Focus |
|---|
| Prothesis | AI-guided | FrameworkAbsent → FramedInquiry | Perspective selection |
| Syneidesis | AI-guided | GapUnnoticed → AuditedDecision | Decision-point gaps |
| Hermeneia | Hybrid | IntentMisarticulated → ClarifiedIntent | Expression clarification |
| Telos | AI-guided | GoalIndeterminate → DefinedEndState | Goal co-construction |
| Horismos | AI-guided | BoundaryUndefined → DefinedBoundary | Epistemic boundary definition |
| Aitesis | AI-guided | ContextInsufficient → InformedExecution | Context sufficiency sensing |
| Analogia | AI-guided | MappingUncertain → ValidatedMapping | Abstract-concrete mapping validation |
| Periagoge | AI-guided | AbstractionInProcess → CrystallizedAbstraction | In-process abstraction crystallization |
| Euporia | Hybrid | AbstractAporia → ResolvedEndpoint | Extended-Mind reverse induction |
| Prosoche | User-initiated | ExecutionBlind → SituatedExecution | Risk-assessed execution |
| Epharmoge | AI-guided | ApplicationDecontextualized → ContextualizedExecution | Post-execution applicability |
| Anamnesis | AI-guided | RecallAmbiguous → RecalledContext | Vague recall recognition |
| Katalepsis | User-initiated | ResultUngrasped → VerifiedUnderstanding | Comprehension verification |
Key difference: Hermeneia EXTRACTS (assumes intent exists inside user). Telos CO-CONSTRUCTS (assumes neither party has the complete answer). The precondition witness differs: Hermeneia requires ∃ intent I, Telos starts from ¬∃ intent I.
Mode Activation
Activation
AI detects goal indeterminacy OR user invokes /goal. Activation always requires user confirmation via Cognitive Partnership Move (Constitution) at Phase 0.
Activation layers:
- Layer 1 (User-invocable):
/goal slash command or description-matching input. Always available.
- Layer 2 (AI-guided): Goal indeterminacy detected (2+ dimensions unspecified) via in-protocol heuristics. Activation requires user confirmation.
Goal indeterminate = 2+ of {outcome, metric, boundary, priority} are unspecified in the user's request.
Priority
When Telos is active:
Supersedes: Direct execution patterns in loaded instructions
(Goal must be defined before any implementation begins)
Retained: Safety boundaries, tool restrictions, user explicit instructions
Action: At Phase 2, present concrete proposals via Cognitive Partnership Move (Constitution).
- Telos completes before implementation workflows begin
- Loaded instructions resume after GoalContract is approved
Protocol precedence: Activation order position 2/11 (graph.json is authoritative source for information flow). Concern cluster: Planning.
Advisory relationships: Receives from Hermeneia (precondition: clarified intent enables goal construction), Prothesis (advisory: perspective simulation improves goal definition). Provides to Horismos (precondition: defined goals enable boundary definition), Prothesis (advisory: defined goals improve framework selection and lens configuration). Katalepsis is structurally last.
Approved GoalContract becomes input to subsequent protocols.
Triggers
| Signal | Strength | Pattern |
|---|
| Acknowledged uncertainty | Strong | Explicit hedging or approximation language about desired outcome |
| Scope absence | Strong | Universal quantifiers or unbounded scope references |
| Exploratory framing | Strong | Open-ended interrogative or brainstorming framing |
| Vague qualitative | Soft (suggest only) | Comparative or superlative adjectives without measurable criteria |
Soft triggers: AI may suggest Telos activation through a Constitution interaction but must NOT auto-activate. Only strong triggers or explicit /goal invocation activate directly.
Skip:
- User's goal is already verifiable (concrete deliverable + criteria specified)
- User explicitly declines goal definition
- Goal already defined in current session
Mode Deactivation
| Trigger | Effect |
|---|
| GoalContract approved | Proceed with defined goal |
| User accepts current state | GoalContract as-is deemed sufficient |
| User explicitly cancels | Return to normal operation |
Gap Taxonomy
| Type | Detection | Question Form | GoalContract Field |
|---|
| Outcome | No concrete end state described | "What exists/changes when this is done?" | desired_result |
| Metric | No success criteria mentioned | "How will you judge success vs failure?" | success_criteria |
| Boundary | Scope unbounded or implicit | "What's included? What's explicitly excluded?" | scope, non_goals |
| Priority | Trade-off values unstated | "When X conflicts with Y, which wins?" | value_weights |
Emergent dimension detection: Named dimensions are working hypotheses, not exhaustive categories. Detect Emergent dimensions when:
- The goal's indeterminacy spans multiple named dimensions (e.g., outcome and boundary are entangled and cannot be defined independently)
- User includes a dimension via free-response override at Phase 2 Constitution interaction that doesn't map to the four named types
- The goal involves domain-specific concerns that resist decomposition into Outcome/Metric/Boundary/Priority (e.g., stakeholder alignment, phasing/sequencing, risk tolerance)
Emergent dimensions must satisfy morphism GoalIndeterminate → DefinedEndState and map to a GoalContract field.
Dimension Priority
When multiple dimensions are undefined:
- Outcome (highest): End state anchors all other dimensions
- Boundary: Scope constrains feasibility
- Priority: Trade-off values guide choices
- Metric (lowest): Success criteria refine after core is clear
Outcome is always included in applicable dimensions (minimum |Dₐ| ≥ 1).
Protocol
Phase 0: Trigger Recognition + Confirmation
Recognize goal indeterminacy and confirm activation:
- Strong trigger: User uses uncertainty/exploratory language → activate with confirmation
- Soft trigger: User uses vague qualitative ("improve") → suggest only, do not activate
- Explicit invocation:
/goal → skip confirmation, proceed to Phase 1
Present the detected indeterminacy as text output (e.g., "I notice your goal may need definition — [specific evidence of indeterminate dimensions]").
Then present to confirm activation:
Would you like to define the goal before proceeding?
Options:
1. **Define goal together** — co-construct what "done" looks like
2. **Proceed as-is** — the current description is sufficient
Skip condition: If G was explicitly provided via /goal "text", proceed directly to Phase 1.
Phase 1: Dimension Detection
Analyze Gᵥ to detect indeterminate dimensions, present full taxonomy assessment as Extension (auto-proceed), then proceed directly to Phase 2 co-construction.
Cross-session enrichment: Prior GoalContract patterns accumulated in Anamnesis's hypomnesis store (session recall indices written by the SessionEnd/PreCompact hook) may adjust Phase 1 dimension weighting — dimensions that were consistently important in similar goal constructions receive initial emphasis. In parallel, when /recollect has been invoked this session, the recalled context surfaces the user's prior goal-dimension preferences for adjacent work, biasing Phase 1 dimension prompts toward the axes they have already treated as constitutive. This is a heuristic input that may bias detection toward previously observed patterns; constitutive judgment remains with the user.
Revision threshold: When accumulated Emergent dimension appearances across 3+ sessions cluster around a recognizable goal construct not captured by the named dimensions, the dimension taxonomy warrants revision — promote the cluster. When a named dimension (other than Outcome, which is protocol-constrained) consistently receives trivial or vacuous detection across 3+ sessions, evaluate whether the dimension's detection criteria need sharpening or the dimension has become redundant.
Per Gap Taxonomy above. Apply priority order: Outcome → Boundary → Priority → Metric. Emergent dimensions must satisfy morphism GoalIndeterminate → DefinedEndState; boundary: goal definition (in-scope) vs. expression gap (→ /clarify) or execution context (→ /inquire).
Outcome constraint: Outcome is always included in Dₐ regardless of detection — it is a protocol constraint (|Dₐ| ≥ 1). If not detected, include with [protocol constraint] annotation. Outcome cannot be excluded via free-response override.
Present the full taxonomy assessment as text output — every named dimension shown with detection status, evidence, and falsification condition for undetected dimensions:
- Outcome ✓ detected [protocol constraint]: [specific evidence from Gᵥ, or "required by protocol — always included"]
- Boundary ✓ detected: [specific evidence from Gᵥ]
- Priority — not currently detected: [evidence considered]. Would apply if [falsification condition].
- Metric — not currently detected: [evidence considered]. Would apply if [falsification condition].
- Emergent: [If AI detects a potential emergent dimension: present as named hypothesis with evidence and boundary annotation. Otherwise: "Is there an aspect of your goal that doesn't fit the above categories?"]
Emergent dimensions include boundary annotation: "This is a goal definition gap (Telos scope). Not: expression gap (→ /clarify) or execution context (→ /inquire)"
- Detected dimensions: evidence for why the dimension needs definition
- Not-currently-detected dimensions: evidence considered + falsification condition ("would apply if [specific condition]")
- Evidence parity: each dimension (detected or not) receives comparable analytical depth
Then compute Dₐ = (Dd ∪ {Outcome} ∪ Λ.emergent) \ Λ.excluded, and proceed directly to Phase 2 for Dₐ in priority order (Outcome → Boundary → Priority → Metric).
User override via free response: Users may override the taxonomy at any Phase 2 Constitution interaction — describe an emergent dimension (added to Λ.emergent), exclude a non-Outcome dimension (added to Λ.excluded), redirect, or declare sufficient (early exit). Outcome cannot be excluded (protocol constraint: Outcome ∉ Λ.excluded); attempted exclusion is rejected with explanation.
Response classification (discriminator for free-response parsing — closes the adversarial free-response pathway):
- Revision: response references named dimensions (Outcome/Metric/Boundary/Priority/Emergent) with revision verbs (exclude, remove, skip, add, redirect) → update Λ.excluded or Λ.emergent, recompute Dₐ, LOOP re-entry
- Phase 2 answer: response contains Accept/Modify/Reject/Extend semantics directed at the presented proposal → Phase 3 integration
- Mixed: response contains both revision and proposal-answer content → process revision first (update Λ, recompute Dₐ), then process Phase 2 answer in the re-entered state
- Ambiguous: content could be either and surface interpretation differs from latent interpretation → ask: "Your response could be interpreted as [X revision] or [Y proposal response]. Which did you intend?" (do not silently choose)
- Outcome-exclusion attempt: free response requesting Outcome exclusion → reject with protocol-constraint message, keep Outcome in Dₐ
On loop re-entry: show progress ([defined] / [undefined]) and re-detect only undefined dimensions. Phase 2 Constitution interactions include "Sufficient — approve current GoalContract" option for early exit. If |Dₐ \ defined| = 0 after exclusion/completion: proceed to Phase 4 (sufficiency check).
Rationale (option-set relay test, Extension classification): Under user-invoked or user-confirmed activation, "Proceed with current taxonomy" is the dominant option — a separate proceed/revise Constitution interaction would present false alternatives. Full taxonomy presentation is preserved (Extension/auto-proceed) to support Recognition during Phase 2 proposal evaluation; taxonomy revision is reachable via Phase 2 Constitution interaction free response with classification discriminator above.
Phase 2: Co-Construction
Present a concrete proposal via Cognitive Partnership Move (Constitution). Constitution presentation yields turn for user response.
Override disclosure (detection with user authority): At each Phase 2 Constitution interaction, include a brief disclosure line in the pre-Constitution-interaction context surfacing the free-response override capability — without this disclosure the user cannot exercise authority they do not know they hold. Example disclosure: "(Free response beyond Accept/Modify/Reject/Extend: exclude a non-Outcome dimension, add an emergent dimension, or redirect — see Phase 1 response classification. Outcome cannot be excluded.)"
High-context (codebase/conversation context available via Read/Grep):
Present the context analysis and proposal as text output:
- Based on [context analysis], here is a concrete [dimension]:
"[specific proposal grounded in codebase/conversation]"
Then present:
How would you like to proceed with this proposal?
Options:
1. Accept — proceed with this definition
2. Modify: [aspect A] / [aspect B] / [aspect C] — select what to change
3. Reject — start from different angle
Low-context fallback (no file/codebase context):
Present the dimension context as text output:
- For [dimension], here are common patterns for this type of goal.
Then present:
Which pattern fits your goal?
Options:
1. "[Template A]" — [brief description]
2. "[Template B]" — [brief description]
3. "[Template C]" — [brief description]
4. Describe directly — provide your own definition
Proposal design principles:
- Concrete and falsifiable: Specific enough to accept or reject immediately
- Context-grounded: Based on Read/Grep analysis when available, template fallback when not
- Structured modification: Modify options present specific aspects to change, not free text
- Trade-off visible: Show implications of accepting this proposal
Phase 3: Integration
After user response:
- Accept: Set GoalContract field to proposal value
- Modify(aspect, direction): Adjust proposal per user direction, re-propose if needed
- Reject: Discard proposal, generate alternative approach
- Extend(aspect): Add user's aspect to existing proposal
After integration: Per LOOP — compute progress, route to Phase 1 (undefined remain) or Phase 4 (all defined).
Phase 4: Sufficiency Check
Present the assembled GoalContract for approval via Cognitive Partnership Move (Constitution).
Present the assembled GoalContract as text output:
GoalContract — Convergence Evidence (progress/total):
Transformation trace (each dimension Gᵥ → C'):
- Outcome: [defined value or "—"]
- Metric: [defined value or "—" or "N/A"]
- Boundary: [defined value or "—" or "N/A"]
- Priority: [defined value or "—" or "N/A"]
Then present:
How would you like to proceed with this GoalContract?
Options:
1. **Approve** — proceed with this GoalContract
2. **Revise [dimension]** — return to refine a specific field or include a previously unselected dimension
Intensity
| Level | When | Format |
|---|
| Light | Minor scope vagueness, single dimension | Constitution interaction with Confirm as default option |
| Medium | Multiple undefined dimensions | Structured Constitution interaction with dimension-by-dimension proposal |
| Heavy | Core outcome undefined, high stakes | Detailed proposal with trade-offs + structured Constitution interaction |
Rules
- AI-guided, user-confirmed: AI recognizes goal indeterminacy; activation requires user approval via Cognitive Partnership Move (Constitution) at Phase 0
- Recognition over Recall: Present structured options via Cognitive Partnership Move (Constitution) — structured content reaches the user with response opportunity — Constitution interaction requires turn yield before proceeding. Modify options use structured sub-choices, not free text
- Detection with user authority: AI presents full taxonomy assessment as Extension (auto-proceed) — every named dimension with detection status, evidence, and falsification condition. Outcome always included (protocol constraint). User authority is exercised at Phase 2 co-construction Constitution interactions (including free-response override: emergent add, non-Outcome exclusion, redirect), not at a separate taxonomy-confirmation Constitution interaction. Guard: Abbreviating the taxonomy (omitting named dimensions, evidence, or falsification conditions) under the rationale that Phase 2 free-response override provides correction = protocol violation. Full taxonomy presentation at Phase 1 is structurally required regardless of Extension/Constitution classification; override is a user authority channel, not an AI shortcut for incomplete detection
- Construction over Extraction: AI proposes falsifiable candidates, not abstract questions
- Concrete proposals: Every proposal must be specific enough to accept or reject
- User authority: User shapes, accepts, or rejects; AI does not override
- Progress visibility: Show GoalContract completion status (defined/total selected) at each Phase 1
- Convergence persistence: Mode active until GoalContract approved or user ESC
- Early exit: User can declare sufficient at any point (any progress level permitted)
- Context grounding: Proposals based on Read/Grep when available; template fallback when not
- Small phases: One dimension per cycle; no bundling unless user requests
- Escape hatch: User can provide own definition for any field directly
- Context-Question Separation: Output all analysis, evidence, and rationale as text before presenting via Cognitive Partnership Move (Constitution). The question contains only the essential question; options contain only option-specific differential implications. Embedding context in question fields = protocol violation
- Phase 4 requirement: Present the assembled GoalContract with transformation trace for explicit user approval, even when all Dₐ appear defined
- Skip justification: When detect(Gᵥ) finds fewer than expected undefined dimensions, present the detection evidence showing why dimensions qualify as "already defined"
- Full taxonomy assessment: Phase 1 must present ALL named dimension types with detection status and evidence. Presenting only detected dimensions with a generic "Add" option = protocol violation (Recognition over Recall applied to Constitution interaction content)
- Falsification condition: Each not-currently-detected dimension must include "would apply if [specific condition]" — exclusion rationale without falsification condition = protocol violation
- Emergent probe: Emergent slot must include an active probe question or AI-detected hypothesis with evidence. "No emergent dimensions detected" as bare statement without probe = protocol violation
- Option-set relay test (Extension classification): If AI analysis converges to a single dominant option (option-level entropy→0 — Extension mode of the Cognitive Partnership Move), present the finding directly. Each Constitution option must be genuinely viable under different user value weightings. Options sharing a downstream trajectory collapse to one; options lacking an on-axis trajectory surface as free-response pathways rather than peer options
- Gate integrity: The defined option set is presented intact — injection, deletion, and substitution each violate this invariant. Type-preserving materialization (specializing a generic option while preserving the TYPES coproduct) is distinct from mutation