U-KSL Core Canon v0.6

0. Core Claim

Kernel Spine Loop (KSL) is the default unit: one bounded Goal aligned with the Kernel or kernels it must preserve, carried through three stages.

Stage 1: map the authorized work.
Stage 2: build according to that map.
Stage 3: check adherence, test, and assess coherence.

Ultra Kernel Spine Loop (U-KSL) is used when the whole requires more than one KSL. The hierarchy is Ultra at the top, Intra in the middle, Infra at the base.

One KSL until one KSL is insufficient. Map in 1. Build in 2. Check and break in 3.

The map is revisable, not a promise that every assumption is final. Revisions belong to the owning Stage 1.

1. Goal and Kernel

Goal states what must become true. Kernel states what must remain true. Map defines the authorized route between them.

Stage 1 aligns Goal and Kernel. A route that can reach the Goal only by violating the Kernel is not valid. Local KSL maps must respect the governing Ultra map and Kernel relationships.

Temporary tool choices or untested assumptions should not be disguised as permanent Kernel requirements.

2. KSL: A Bounded Three-Stage Operation

A KSL has a bounded local Goal, Kernel, map, build, and verification. Its Stage 1 defines enough scope, exclusions, work, receipts, checks, and amendment ownership to authorize its Stage 2.

Its Stage 2 builds within that map. Its Stage 3 checks what Stage 2 actually did against what Stage 1 authorized and assesses whether the result satisfies the local Goal.

A local PASS permits exit from that KSL and progression to the next authorized KSL or handoff. It does not prove that the whole Ultra is complete. Necessary checks must pass; extra red-teaming is not a ritual required for every exit.

3. Ultra, Intra, Infra

ULTRA - TOP
The whole Goal, Kernel relationships, and supervisory map.
    |
    v
INTRA - MIDDLE
The bounded KSLs that carry the work toward the Ultra.
Each KSL has its own Stage 1, Stage 2, and Stage 3.
    |
    v
INFRA - BASE
The infrastructure: the actual foundation and integrated build
being established or changed through those KSLs.

Ultra sets the whole and its bounds. Intra is the middle KSL layer. Infra is the base infrastructure.

Intra does not mean the steps inside a single KSL. Infra does not mean the KSL list. Local phases, steps, receipts, and checks remain parts of their owning KSL; they do not redefine the hierarchy.

At Ultra scale, Stage 1 maps the whole, Stage 2 traverses the Intra KSLs, and Stage 3 sanity-checks the Infra as one complete build against the Ultra.

4. Roles: Operator, Orchestrator, Subagents

U-KSL is built to run unattended once its map is approved. Three roles carry it.

OPERATOR      sets the Goal and Kernel, maps Ultra Stage 1 with the
              orchestrator, approves the Ultra map, receives the result.
ORCHESTRATOR  holds the approved Ultra map, traverses the Intra KSLs,
              runs Ultra Stage 3, reports to the Operator.
SUBAGENT      runs one KSL: its own Stage 1, Stage 2, and Stage 3,
              inside the Ultra map.

The Operator approves maps, not steps. Approval of the Ultra map authorizes the whole traversal. No step, local map, local PASS, or handoff waits for the Operator.

Wherever this canon says authorized, it means authorized by the governing map. It never means a fresh request to the Operator.

A run returns to the Operator in three cases only: the Ultra map has to change, the failure ladder is exhausted, or the run is complete.

The roles describe authority, not headcount. One agent may hold the orchestrator role and run every KSL itself; the same rules apply.

5. Ultra Stage 1: Align, Bound, Map

Ultra Stage 1 owns the top-level map and amendments to that map. The Operator and the orchestrator map it together. It establishes the minimum sufficient overview for bounded traversal, not detailed internal maps for every future KSL.

Ultra Goal and Kernel relationships
In-scope and out-of-scope boundaries
Bounded Intra KSL set and first KSL
Dependencies, order, and authorized overlap
Each KSL's required outputs and acceptance checks
Handoffs and composition requirements for the Infra
Receipt classes and whole-build verification target
Signal routing and amendment ownership
Traversal and exit bounds

The map must say enough to walk safely: what the whole is, which KSLs are needed, how they connect, what evidence is required, and where wrongness returns.

The Ultra map is the contract. It fixes each KSL's required outputs, handoffs, and acceptance checks, so a local map can change the route but not what is delivered or how it is judged.

Ultra Stage 1 ends when the Operator approves the Ultra map. That approval authorizes the whole traversal, starting with the first KSL's Stage 1. Later KSLs are mapped locally when reached, and those local maps need no Operator approval while they stay inside the Ultra map. The Ultra map is not blanket permission to execute unmapped work: every KSL still maps before it builds.

Map enough to walk safely, not everything in advance.

6. Ultra Stage 2: Walk the Map Through the Intra

The orchestrator traverses the authorized KSLs in dependency order and hands each one to a subagent. Each KSL retains its own full operation:

KSL Stage 1 - map its bounded work
KSL Stage 2 - build that work
KSL Stage 3 - check adherence and coherence
Local PASS - exit and proceed to the next authorized handoff

Performing a local KSL's Stage 1 or Stage 3 during Ultra Stage 2 is part of traversing that KSL. It does not authorize changing the Ultra map from inside execution.

Stage 2 may record signals, pause affected work, preserve receipts, and return a defect to the owning Stage 1. It may not decide and apply an unplanned fix. Stage 2 can implement a fix only after Stage 1 maps it. A failed step may be run once more, unchanged, before it returns; a changed step is a fix, not a retry.

Successful KSLs proceed without needless remapping and without waiting for the Operator. If a local correction would fundamentally change the Ultra workflow, pause the affected route and return to Ultra Stage 1 first. That return goes to the Operator, because the approved map is changing.

7. Stage 3: Check Adherence, Challenge, Assess

KSL Stage 3: Check the Local Build

First, check whether Stage 2 followed its local Stage 1 map. Did it stay within the bound, preserve the Kernel, produce the required outputs, and leave supporting receipts?

If the build deviated, return to local Stage 1 to map the correction. The original requirements may remain valid; that does not authorize repairing the build directly in Stage 2 or Stage 3. Do not rewrite the requirements merely to excuse a faulty build.

When the build respects the map, perform the assessment the result needs. Stage 3 may test, stress, red-team, or deliberately break things to expose defects. Testing hardening is assessment; implementing hardening is a build change.

Any discovered defect or required hardening returns to the owning Stage 1. Once Stage 2 builds the mapped correction, Stage 3 repeats the failed checks and other checks affected by the change. When adherence and required assessment pass, exit the KSL.

Ultra Stage 3: Final Infra Sanity Check

Ultra Stage 3 is the last sanity check of the whole build. After the mapped KSL traversal, assess the actual Infra — the infrastructure and integrated result — against the Ultra Goal, Kernel, and map.

Did the traversal respect the approved Ultra map?
Do the KSL outputs work together in the actual infrastructure?
Does the whole build satisfy the Ultra Goal and preserve its Kernel?
Do receipts and whole-system checks support that judgment?
What remains unverified, and does it block the mapped exit?

This is not another production KSL or a place to finish missing implementation. It is the final whole-build assessment. It need not blindly repeat every passed local check, but local receipts do not replace checking the actual integrated result.

Ultra Stage 3 may test or break the whole system when needed. A defect follows the same return path: owning Stage 1 maps the fix, Stage 2 builds it, Stage 3 rechecks the affected result.

KSL PASS does not imply Ultra PASS.
Local validity is evidence. Whole-build coherence is still required.

8. Recursive Healing: No Fix Without a Map

Healing admits wrongness without discarding everything that still works. Identify whether the defect is in the build, the local map, or the Ultra map; map the correction at the level that has authority over the required change.

Stage 3 finds a defect
    -> owning Stage 1 maps the correction
    -> Stage 2 builds the authorized correction
    -> Stage 3 repeats the affected checks
    -> PASS and exit, or route the remaining defect again

A defect discovered during Stage 2 can return to the owning Stage 1 immediately; there is no need to keep building a known failure just to reach Stage 3. When the cause is not yet known to be in the map, the failed step is retried once, unchanged, first.

Build deviated from the local map

Return to that KSL's Stage 1 to map corrective work, even if its original Goal, Kernel, and requirements are still correct.

Local map or assessment exposed a local defect

Return to that KSL's Stage 1, provided the correction stays within the approved Ultra workflow and bounds. The fix is built without Operator approval and leaves a receipt.

Local fix fundamentally changes the Ultra workflow

Return to Ultra Stage 1 first. Amend the parent map with the Operator, who approves the amendment. Align affected local maps, then traverse only the newly authorized work.

Locally valid KSLs fail to compose

Return the composition defect to Ultra Stage 1 and the Operator. Preserve local work and receipts that still pass; recheck any results affected by the amendment.

Discovery location alone does not determine ownership. An isolated local defect found in the final Infra check can return to the owning KSL's Stage 1. A defect in the whole's scope, dependencies, workflow, or composition belongs to Ultra Stage 1.

Neither Stage 2 nor Stage 3 owns repair mapping. A small defect can receive a small correction map; returning to Stage 1 does not require restarting valid work.

Healing does not promise eventual success. It gives discovered wrongness an explicit route, and the failure ladder gives that route an end.

9. The Failure Ladder

Healing needs a stop rule. One rule applies at every level: two failures send the work up one level.

1. RETRY        A step or check fails: run it once more, unchanged.
2. LOCAL REMAP  It fails again: return to that KSL's Stage 1 and map a
                fix. A fix inside the Ultra map is built unattended and
                leaves a receipt.
3. ULTRA REMAP  The mapped fix fails twice, or the fix would change the
                Ultra map: return to Ultra Stage 1. Remap with the
                Operator, who approves the amended map.
4. REFRAME      The remapped Ultra fails twice: stop and report to the
                Operator. The question is now the Goal and Kernel.

The count belongs to the map, not the step. Each map gets two attempts, and a newly approved map starts a fresh count.

A retry is the identical step. It tests whether the failure was in the run or in the map. A changed step is an unmapped fix. When the cause is already known to be in the map, skip the retry and return to Stage 1.

A local fix may change the route. It may not change the contract. A fix that touches a KSL's required outputs, handoffs, or acceptance checks, the Kernel, or the KSL set changes the Ultra map and goes to rung 3. Loosening a check so a build passes is such a change.

The receipt for a local remap states what failed, what changed, and why the change is inside the Ultra map. Ultra Stage 3 tests that claim when it asks whether the traversal respected the approved Ultra map.

A return to the Operator carries the signal, the receipts, and what was tried. The Operator and the orchestrator work out the correction, remap in the owning Stage 1, and the run resumes.

10. Receipts and Preservation

A receipt is evidence of what was authorized, built, tested, rejected, learned, preserved, or changed. Receipts connect a result to the map and verification that support it.

Preserve valid work and receipts during healing. An amendment need not erase an earlier local PASS, but historical validity is not automatic evidence that an altered build still passes. Re-verify affected results.

Keep what still holds. Change only what the correction requires. Check what the change affects.

11. Signals and Ownership

A signal may expose a build deviation, failed test, broken assumption, missing KSL, incompatible handoff, or whole-build failure. Record it rather than suppressing it or hiding its correction inside execution.

Record the signal and relevant evidence.
Preserve valid work and pause the affected bound when necessary.
Identify the change required and the Stage 1 that owns it.
Map the correction there; escalate if it changes the Ultra workflow.
Build only the newly authorized correction in Stage 2.
Recheck in Stage 3.

A child may reveal that the parent map is wrong. It may not authorize a fundamental parent change on its own.

12. PASS, Progression, and Completion

A local KSL PASS means its required adherence and coherence checks are satisfied. Where the local map still respects the Ultra map and dependencies are ready, proceed to the next authorized KSL. Do not reopen the Ultra map merely because a KSL completed successfully, and do not wait for the Operator.

Ultra Stage 3 PASS means the actual whole build satisfies the current Ultra map and required checks. That completes the run. The orchestrator reports the result to the Operator with its receipts and whatever remains unverified.

The run exits on Ultra PASS.
From the report, the Operator may start new work:
ITERATE / EXPAND / REFRAME

Iteration, expansion, or reframing is new work. It returns to the appropriate Stage 1 for mapping and, at Ultra level, Operator approval. Operator approval does not convert failed verification into a PASS. The system permits a real bounded exit; it does not demand endless testing or revision.

13. Self-Same Law

The Ultra and each KSL use the same discipline at their own scope:

1 - align, bound, and map
2 - build within that map
3 - check adherence, challenge when needed, and assess
Failure - retry once, unchanged; then return to the owning 1,
          build in 2, recheck in 3
Fix fails twice - go up one level
PASS - exit the bounded operation

Recursion does not erase the hierarchy. Ultra remains the top-level whole, Intra the KSL layer, and Infra the infrastructure. Not every task or asset needs to become a KSL; create a KSL where a bounded goal, ownership, and verification justify one.

14. Final Canon

Use one KSL when one is enough. Form U-KSL when multiple KSLs must serve one whole.

Ultra: the top-level Goal and map. Intra: the middle KSL layer. Infra: the base infrastructure.

Map in Stage 1. Build in Stage 2. Check adherence and break or test in Stage 3. Map every fix in Stage 1, build it in Stage 2, and repeat the affected Stage 3 checks.

Escalate a local correction to Ultra Stage 1 when it fundamentally changes the Ultra workflow. Preserve valid work. Progress when the local checks pass, without waiting for the Operator.

Retry a failed step once, unchanged. Two failures send the work up one level: step to KSL map, KSL map to Ultra map, Ultra map to the Operator.

Ultra Stage 3 is the final sanity check of the whole build. Local PASS is not Ultra PASS. When the whole passes, the run is complete and the orchestrator reports to the Operator with receipts.

The Operator approves maps, not steps. Once the Ultra map is approved, the run proceeds unattended. It returns to the Operator only when the Ultra map must change, the failure ladder is exhausted, or the run is complete.

Future durable, not future proof.