Realign

How does the fused candidate need to be shaped?

Options:
1. Confirm — the candidate fuses the three horizons faithfully; carry forward to Phase 3 integration
2. Widen(axis) — broaden the candidate along the named axis; specify the axis
3. Narrow(axis) — restrict the candidate along the named axis; specify the axis
4. Fuse(adjacent) — fuse with an adjacent abstraction; specify the adjacent reference
5. Reorient(axis) — turn the candidate onto an orthogonal axis; specify the new axis
6. Dismiss — the candidate is not a faithful fusion; exit without write

Fused direction line:
  <fused_line>

Per-horizon trace:
  Horizon A (inscribed direction): <preserved | transformed | dropped excerpts>
  Horizon B (external signals):    <preserved | transformed | dropped excerpts>
  Horizon C (user pre-understanding): <preserved | transformed | dropped excerpts>

Write target: <project_guide_path> (single direction line)
Rollback: git revert / git checkout

How would you like to proceed with the fused line?

Options:
1. Approve — write the fused line to <write_target>, replacing the existing direction line
2. Modify — adjust the fused line before write (specify how)
3. Reject — discard the fused candidate; the existing direction line remains unchanged; emit NoFusionNote
4. Defer — emit the fused line and trace as a session-text artifact without writing

── FLOW ──
Realign(scope) → Phase0(scope, user_confirm) →
  scoped(scope): Bind(Horizon_A, Qc) → Surface(Horizon_A, Horizon_B) → Elicit(Horizon_C, Qc) →
    Compose(candidate, trace) → present(candidate, trace) → Qc(shape) → Stop → V →
      Confirm: Phase3
      Widen(axis) | Narrow(axis) | Fuse(adjacent) | Reorient(axis): regenerate(candidate, trace) → re-present Phase 2
      Dismiss: emit(NoFusionNote) → converge
    Phase3: present(fused_line, trace, write_target, rollback) → Qc(approve) → Stop → A →
      Approve: Write(fused_line, project_guide) → emit(FusedDirection)
      Modify(adjustments): regenerate(candidate, trace) → re-present Phase 3
      Reject: emit(NoFusionNote) → no write
      Defer: emit(FusedDirectionDraft) → no write
    converge

── MORPHISM ──
ThreeHorizons
  → resolve_scope(user_confirm)         -- Phase 0 scope determination (channels, cross_session)
  → bind(Horizon_A, user_confirm)       -- Phase 1 inscribed-direction binding (convention-inferred path × marker, disambiguated when ambiguous, empty when nothing inscribed)
  → surface(Horizon_A, Horizon_B)       -- Phase 1 inscribed direction + external-signals direction
  → elicit(Horizon_C, user)             -- Phase 1 user pre-understanding (separate Constitution interaction)
  → compose(candidate, trace)           -- Phase 1 fusion candidate + per-horizon transformation trace
  → present(candidate, V)               -- Phase 2 dialectical shaping
  → [V = Confirm: Phase 3; V = shape-move: regenerate; V = Dismiss: NoFusionNote]
  → present(fused_line, trace, A)       -- Phase 3 final approval
  → [A = Approve: write(fused_line, project_guide); else: no write]
  → emit(FusedDirection | NoFusionNote | FusedDirectionDraft)
                                         -- inscription on Approve, session text on other dispositions
  → FusedDirection | NoFusionNote | FusedDirectionDraft
requires: horizons_unfused(scope) ∧ scope_resolved(user)
deficit:  HorizonsUnfused
preserves: ProjectGuideHistory             -- read-only audit; horizons are derived
invariant: Recognition over Direction-Mutation, Fusion over Addendum
                                            -- ProjectGuideDirectionLine is mutated at Phase 3 Approve;
                                            -- mutation is gated by Phase 3 Constitution final approve;
                                            -- rollback is git operation on the project guide

── TYPES ──
Scope            = { channels: Set(Channel), cross_session: Bool }
Channel          ∈ { OpenIssues, PullRequestReviews, ClosedDispositionTrajectory, CurrentSessionUtterances } ∪ Emergent
BindingSource    ∈ { ExplicitArg, ConventionInferenceUnique, UserDisambiguation, EmptyInscription }
Horizon          ∈ { InscribedDirection, ExternalSignalsDirection, UserPreUnderstanding }
HorizonContent   = { horizon: Horizon, content: String, citations: List(String) }
HorizonRole      ∈ { Preserved, Transformed, Dropped }
TraceEntry       = { horizon: Horizon, role: HorizonRole, excerpt: String }
FusionCandidate  = { line: String, trace: List(TraceEntry) }
V                = ShapingMove ∈ { Confirm, Widen(axis), Narrow(axis), Fuse(adjacent), Reorient(axis), Dismiss }
A                = ApprovalDisposition ∈ { Approve, Modify(adjustments), Reject, Defer }
FusedDirection         = session text { fused_line, trace, write_path, rollback_hint }
NoFusionNote           = session text { surfaced_horizons, dismissed_candidate, dismiss_reason }
FusedDirectionDraft    = session text { fused_line, trace, suggested_apply_path }
Phase            ∈ {0, 1, 2, 3}

── SCOPE-BINDING ──
bind(scope) = explicit_arg ∪ defaults
Priority: explicit_arg > defaults

/realign --channels=<set>          → Scope.channels = <set>
/realign --cross-session           → Scope.cross_session = true
/realign --guide=<path>            → Optional Phase 1 Horizon_A override (binds the inscribed-direction path directly, bypassing convention-inference)
/realign --direction-marker=<hdr>  → Optional Phase 1 Horizon_A override (binds the inscribed-direction marker header within the chosen path)
/realign (alone)                   → Scope.channels = default set; Scope.cross_session = false; Horizon_A is resolved by Phase 1 convention-inference with Constitution disambiguation when ambiguous

When Phase 0 defaults are inferred, Phase 0 surfaces them in the scope-confirmation Constitution interaction so the user can override before scan begins.

── PHASE TRANSITIONS ──
Phase 0: scope_seed → resolve_defaults → Qc(scope_confirm) → Stop → Scope         -- scope determination [Tool]
Phase 1: Scope → InferGuide(convention) → Qc(horizon_a_bind) → Stop → (path, marker)  -- Horizon_A binding (skipped when --guide / --direction-marker fully specify) [Tool]
           (path, marker) → Read(path, marker) → Horizon_A                         -- inscribed direction (empty when nothing inscribed) [Tool]
           Scope → Scan(channels) → Horizon_B                                      -- external-signals direction [Tool]
           Qc(pre_understanding) → Stop → Horizon_C                                -- user pre-understanding (separate gate) [Tool]
           Compose(Horizon_A, Horizon_B, Horizon_C) → candidate, trace             -- fusion candidate + trace
Phase 2: present(candidate, trace) → Qc(shape) → Stop → V → integrate              -- dialectical shaping [Tool]
           V ∈ {Widen, Narrow, Fuse, Reorient} → regenerate(candidate, trace) → Phase 2 re-entry
           V = Dismiss → emit(NoFusionNote) → converge
           V = Confirm → Phase 3
Phase 3: present(fused_line, trace, write_target, rollback) → Qc(approve) → Stop → A  -- final Constitution interaction [Tool]
           A = Approve → Write(fused_line, project_guide) → emit(FusedDirection)
           A = Modify → regenerate(candidate, trace) → Phase 3 re-entry
           A = Reject → emit(NoFusionNote)
           A = Defer → emit(FusedDirectionDraft)

── LOOP ──
Phase 2 shaping loop max 5 iterations. Exhausted: surface assembled candidate as FusedDirectionDraft (defer) → converge.
Phase 3 Modify re-entry max 3 iterations. Exhausted: surface assembled candidate as FusedDirectionDraft (defer) → converge.
Convergence evidence: per disposition, emit one of {FusedDirection, NoFusionNote, FusedDirectionDraft}.

── CONVERGENCE ──
fused      = ∃ step ∈ history : V(step) = Confirm
approved   = A ∈ {Approve, Reject, Defer}
written    = A = Approve ∧ write_succeeded
session_text(realign) ∋ {FusedDirection | NoFusionNote | FusedDirectionDraft}

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 resolve_defaults  (sense)        → Internal analysis (default channel set assembly)
Phase 0 scope_from_arg    (extension)    → TextPresent+Proceed (when explicit_arg fully specifies scope; proceed with bound scope; Phase 3 Modify re-entry can adjust)
Phase 0 Qc                (constitution) → present (scope confirmation; when scope partially or fully inferred)
Phase 1 InferGuide        (sense)        → Internal analysis (convention-inferred guide candidate set × enumerated direction markers + Emergent slot)
Phase 1 Qc                (constitution) → present (Horizon A binding; constitutive user pair selection when convention-inference returns multiple candidates × markers; relayed when convention-inference returns a unique pair or when --guide / --direction-marker fully specifies)
Phase 1 Read              (observe)      → Read (inscribed direction at the bound path × marker; empty Horizon A when nothing inscribed is acceptable input to fusion)
Phase 1 Scan              (observe)      → Read / Grep / Bash (channel substrates per channel kind: open issues, pull-request reviews, closed disposition trajectory, current session utterances)
Phase 1 Qc                (constitution) → present (user pre-understanding; constitutive user utterance; conflation with channel attribute list is the failure mode this gate is designed to prevent)
Phase 1 Compose           (sense)        → Internal analysis (fusion candidate + per-horizon transformation trace; horizons are not privileged against each other; addendum patterns are surfaced as preserved-with-no-transformation traces for user verification)
Phase 2 present           (extension)    → TextPresent+Proceed (candidate-with-trace pre-gate)
Phase 2 Qc                (constitution) → present (dialectical shaping; constitutive user verdict per shaping step; widen / narrow / fuse / reorient / confirm / dismiss vocabulary defined at Phase 2 of this file)
Phase 2 integrate         (track)        → Internal Λ update (shaping-move recording; candidate regeneration on shape moves)
Phase 3 present           (extension)    → TextPresent+Proceed (fused line + trace + write target + rollback pre-gate)
Phase 3 Qc                (constitution) → present (final approval; writable side effect; user authority required)
Phase 3 Write             (transform)    → Write / Edit (fused line replaces existing direction line in project guide; Approve disposition only)
Phase 3 emit              (extension)    → TextPresent+Proceed (FusedDirection or NoFusionNote or FusedDirectionDraft, per disposition)
converge                  (extension)    → TextPresent+Proceed (convergence evidence trace)

── MODE STATE ──
Λ = { phase: Phase, scope: Scope,
      horizon_a_binding: { path: Optional(Path), marker: Optional(String), source: BindingSource },
      Horizon_A: HorizonContent, Horizon_B: HorizonContent, Horizon_C: HorizonContent,
      candidate: Optional(FusionCandidate),
      shaping_history: List<(FusionCandidate, V)>, shape_iterations: Nat, modify_iterations: Nat,
      fused_line: Optional(String), write_path: Optional(Path),
      disposition: Optional(A), active: Bool, cause_tag: String }

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). Realign composes with `/probe` upstream when a probe disposition routes to /realign. Realign composes with `/induce` laterally when an in-conversation abstraction crystallization references the project guide direction (the crystallized abstraction may be inscribed to the direction line via a subsequent /realign invocation). Composition targets are determined at runtime by disposition and session context, not by a pre-committed structural registry — Realign is a utility skill, not a core protocol.