Gap Enforcing Decisions

Decision Enforcement

Apply the mandatory decision rules to the gap ledger and destruction outcomes. Produce state changes, readiness gate values, execution queue entries, and governor escalations.

Every rule must be evaluated. No rule may be skipped. Every block must have explicit rationale.

Process

Step 1: Collect Inputs [S]

Gather from prior skill outputs and register state:

1. Gap Ledger (scored and ranked gap records from gap-computing-ledger).
2. Destruction Log (outcomes from gap-running-destruction).
3. Current confidence states for all hypotheses.
4. Current support states for all proposals.
5. Decision deadlines and their statuses.
6. Active blockers.
7. Any governor responses from execution/queue/.

Gate: inputs_collected: bool -- gap ledger and destruction log both available. If either is missing, halt: "Cannot enforce decisions without gap computation and destruction pass."

• Pass: Step 2.
• Fail: halt. Report which input is missing.

Step 2: Apply Priority Rule [S]

Rule: Always work on the gap with the highest (gap score x blast radius).

1. Read the ranked gap list from gap-computing-ledger.
2. Confirm the #1 gap is the current work priority.
3. If the current execution queue contains tasks not aligned with the top gap, flag them.

Gate: priority_confirmed: bool -- top gap identified, priority stated.

• Pass: Step 3.
• Fail: re-rank gaps.

Step 3: Apply Execution Rule [R]

Rule: A task is valid only if it reduces a top-3 open gap and produces T1 or T2 evidence.

For each proposed or active task:

List valid tasks and rejected tasks with rejection reason.

Gate: execution_filtered: bool -- every task evaluated. Invalid tasks rejected with reason.

• Pass: Step 4.
• Fail: re-evaluate tasks against current top-3 gaps.

Step 4: Apply Evidence Promotion Rule [R]

Rule: T3 evidence cannot directly produce SUPPORTED. T2 can support RESEARCHED, never SUPPORTED.

For each hypothesis currently marked or proposed for SUPPORTED:

If any hypothesis is marked SUPPORTED without qualifying T1, reclassify it.

Gate: promotion_enforced: bool -- no hypothesis exceeds the confidence ceiling allowed by its evidence.

• Pass: Step 5.
• Fail: reclassify the offending hypotheses. Document the reclassification with rationale.

Step 5: Apply Kill Rule [R]

Rule: If kill condition is met or strong contradictory T1 evidence exists, mark target BROKEN.

For each hypothesis and proposal:

Gate: kill_rule_applied: bool -- every hypothesis checked against its kill condition and contradictory evidence.

• Pass: Step 6.
• Fail: check which hypothesis was missed.

Step 6: Apply Deadline Rule [R]

Rule: Exceeded deadline forces KILL, PIVOT, or COMMIT. No indefinite exploration.

For each decision deadline:

Gate: deadlines_enforced: bool -- no EXCEEDED deadline without forced disposition.

• Pass: Step 7.
• Fail: force disposition for each exceeded deadline.

Step 7: Apply Contradiction Rule [R]

Rule: Contradictions between hypotheses, architecture, or solution block execution until resolved.

Review contradiction findings from destruction pass:

Gate: contradictions_resolved_or_blocked: bool -- every contradiction either resolved or blocking execution.

• Pass: Step 8.
• Fail: identify unaddressed contradictions.

Step 8: Apply Architecture Validity Rule [R]

Rule: Architecture-dependent work is blocked if required conditions are unmet.

1. Read Growth Architecture required conditions.
2. Check each condition against current register state.
3. If any required condition is unmet, block architecture-dependent execution and mark architecture support state as BLOCKED.

Examples:

• PLG without self-serve capability: blocked.
• Sales-led without identified budget owner: blocked.
• Network without collaboration mechanism: blocked.

Gate: architecture_validated: bool -- architecture conditions checked, blocks applied if needed.

• Pass: Step 9.
• Fail: check which conditions were not evaluated.

Step 9: Apply Solution Contamination Rule [R]

Rule: If validation tests are solution-led rather than problem-led, invalidate the test.

Review evidence items and any proposed validation activities:

Gate: contamination_checked: bool -- all evidence and proposed tests evaluated for solution bias.

• Pass: Step 10.
• Fail: flag contaminated tests.

Step 10: Apply Readiness Gate Rule [R]

Rule: Downstream systems may proceed only if gate predicate passes.

Evaluate sell_ready:

sell_ready = true only if ALL four conditions pass.

Evaluate scale_ready:

scale_ready = true only if ALL five conditions pass.

Gate: readiness_evaluated: bool -- both gates evaluated with explicit pass/fail per condition.

• Pass: Step 11.
• Fail: re-evaluate. Every condition must have a clear pass/fail.

Step 11: Apply Focus Rule [S]

Rule: Maximum 3 active gaps at any time.

1. Count active gaps (those with status OPEN or IN_PROGRESS).
2. If count > 3, defer lowest-priority gaps until active count = 3.
3. Document what was deferred and why.

Gate: focus_enforced: bool -- active gap count <= 3.

• Pass: Step 12.
• Fail: defer gaps until count <= 3.

Step 12: Generate Outputs [S]

Compile all rule application results into:

1. State changes: list of confidence/support state reclassifications with rationale.
2. sell_ready / scale_ready flags with per-condition breakdown.
3. Execution queue: top-3 gap-reduction tasks (valid per execution rule).
4. Governor escalations: for values decisions, judgment calls, and ground-truth blockers that the system cannot resolve. Each escalation must include: decision needed, decision type, why system cannot decide, options with consequences, recommendation if any, what is at stake.
5. Blocks: list of blocked execution paths with rationale.

Gate: outputs_complete: bool -- all five output categories populated (even if empty with "none").

• Pass: output.
• Fail: identify which output category is missing.

Edge Cases

Boundaries

In scope: Decision rule application, confidence/support state reclassification, readiness gate evaluation, execution queue generation, governor escalation generation, block enforcement.

Out of scope: Computing gap scores (gap-computing-ledger), running destruction protocol (gap-running-destruction), conducting research (strategist skills), writing to the register (agent handles I/O).