How User Confirmation Checkpoints Prevent Rework in Stages 0 and 1.5 of the RIA-TV++ Pipeline

User confirmation checkpoints in Stages 0 and 1.5 enforce early validation of the skeleton structure and candidate list, preventing costly cascade rework across the RIA-TV++ pipeline.

The kangarooking/cangjie-skill repository implements a rigorous methodology called RIA-TV++ for constructing executable skills. Central to this approach are two mandatory user confirmation checkpoints that lock in critical decisions before downstream automation proceeds. These checkpoints directly implement the "用户参与" (user participation) invariant defined in the pipeline's core documentation.

---

What Are User Confirmation Checkpoints?

User confirmation checkpoints are explicit gates in the RIA-TV++ workflow where human approval is required before the pipeline continues. Unlike automated validation, these checkpoints force explicit sign-off on foundational artefacts—ensuring that subsequent stages operate on stable, validated inputs.

According to [methodology/00-overview.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/00-overview.md#L82-L84), the pipeline defines these as non-optional steps. Skipping or failing a checkpoint terminates execution, protecting the integrity of generated outputs.

---

Stage 0 Checkpoint: Skeleton Confirmation

Location and Purpose

The first checkpoint appears immediately after the "Adler" reading stage in [methodology/01-stage0-adler.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/01-stage0-adler.md). At this point, the system generates the R-I-A backbone—the high-level structural skeleton that will guide all downstream processing.

Implementation

# stage0-adler.py – skeleton confirmation

def confirm_skeleton(skeleton):
    print("\n=== 骨架预览 ===")
    print(skeleton)
    ans = input("请确认骨架是否完整 (y/n): ")
    if ans.lower() != "y":
        raise RuntimeError("用户未确认骨架 – 终止流水线")
    return True

How It Prevents Rework

• Structural stability: The skeleton defines the R (Reading), I (Indexing), and A (Action) components that parallel extraction stages will populate. If this structure shifts later, all populated sections become invalid.
• Cascade containment: Without confirmation, a skeleton revision in Stage 2 or 3 would force regeneration of SKILL.md, INDEX.md, and DIGEST.md—potentially invalidating hours of automated processing.
• Decision finality: The checkpoint enforces a "decide once" principle. Once confirmed, the skeleton becomes immutable for the current pipeline run.

---

Stage 1.5 Checkpoint: Candidate List Confirmation

Location and Purpose

The second checkpoint follows triple verification in [methodology/03-stage1.5-triple-verify.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/03-stage1.5-triple-verify.md). Here, the user reviews items that passed three-layer validation and approves the final candidate set.

Implementation

# stage1.5-triple-verify.py – candidate list confirmation

def confirm_candidates(accepted, rejected):
    print("\n=== 通过的候选项 ===")
    for c in accepted: print("- " + c)
    ans = input("请确认上述候选项 (y/n): ")
    if ans.lower() != "y":
        raise RuntimeError("用户未确认候选项 – 终止流水线")
    # clean up rejected items only after user approval

    for r in rejected: os.remove(r)

How It Prevents Rework

• Eliminates back-and-forth: Without this gate, items could enter the RIA++ construction stage, get linked and indexed, then later be flagged for removal—requiring painful unlinking and index rebuilding.
• Clean separation: Rejected candidates are permanently discarded (os.remove) only after confirmation, preventing accidental data loss while ensuring no zombie entries persist.
• Pressure-test protection: The RIA++ stage (Stage 2) subjects candidates to intensive validation. Confirming the list upfront avoids wasting computation on items destined for rejection.

---

The Invariant Connection: "用户参与" and "可追溯"

Both checkpoints directly serve two documented invariants in [methodology/00-overview.md](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/00-overview.md):

Invariant	How Checkpoints Enforce It
用户参与 (User Participation)	Mandates human judgment at structurally significant moments, not just as final approval
可追溯 (Traceability)	Creates clear decision points where every confirmed element has explicit provenance

This traceability makes future edits predictable. When [SKILL.md](https://github.com/kangarooking/cangjie-skill/blob/main/SKILL.md) needs updates, maintainers can trace back to the exact confirmed skeleton and candidate list that produced it.

---

Rework Prevention Mechanism: A Comparison

Risk Without Checkpoints	How Checkpoint Prevents It
Skeleton redesign in Stage 2 invalidates parallel extraction results	Stage 0 confirmation locks structure before any parallel work begins
Candidate oscillation causes repeated linking/indexing cycles	Stage 1.5 confirmation finalizes the set before RIA++ construction
Unclear provenance makes debugging skill failures difficult	Both checkpoints create auditable decision records tied to specific commits

---

Summary

• Stage 0 skeleton confirmation in methodology/01-stage0-adler.md locks the R-I-A backbone before downstream stages invest effort in populating it.
• Stage 1.5 candidate confirmation in methodology/03-stage1.5-triple-verify.md finalizes the verified item set before costly RIA++ construction and pressure-testing.
• Both checkpoints implement the "用户参与" invariant, ensuring human judgment at critical architectural decision points.
• The "可追溯" invariant is satisfied through explicit, logged confirmation points that create clear audit trails for generated skills.

---

Frequently Asked Questions

What happens if a user rejects the skeleton in Stage 0?

The pipeline raises a RuntimeError and terminates immediately. The user must revise inputs and restart. This hard failure prevents continuation with an unvalidated structure that would guarantee downstream rework.

Why is Stage 1.5 positioned between triple verification and RIA++ construction?

This placement is deliberate. Triple verification filters candidates, but human judgment catches edge cases automated rules miss. Confirming after triple verification but before RIA++ construction avoids the most expensive rework: unlinking and re-indexing items that entered the skill pipeline prematurely.

Can these checkpoints be automated or bypassed in CI/CD environments?

The source code shows no bypass mechanism—the input() calls and explicit RuntimeError raises are mandatory. For automated environments, the repository would need wrapper scripts that pre-validate inputs and simulate confirmation, or a flag-override feature that does not currently exist.

How do these checkpoints relate to the final SKILL.md output?

SKILL.md consumes the confirmed skeleton structure and the confirmed candidate list as foundational inputs. Every section in the generated skill traces back to artefacts that passed through these two gates, ensuring the final output reflects explicitly validated decisions rather than speculative automation.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}