AGENT SKILL

forge-verification

Governs logic verification, evidence coverage, confidence calibration, and the REFORGE protocol during the FORGE Gate phase. Use when the Reasoner enters Phase G to check logical soundness (fallacy scan), verify evidence coverage, assess decision completeness, calibrate the 4-factor confidence score, and decide pass/emit or trigger a single REFORGE revision pass.

License 许可
Apache-2.0
所属仓库
Rynaro/magicite
最近更新
2026-10-14
Stars
★ 2
Forks
0

01 前言 Front Matter

name
forge-verification
metadata
{ "phase": "G", "methodology": "FORGE" }
description
Governs logic verification, evidence coverage, confidence calibration, and the REFORGE protocol during the FORGE Gate phase. Use when the Reasoner enters Phase G to check logical soundness (fallacy scan), verify evidence coverage, assess decision completeness, calibrate the 4-factor confidence score, and decide pass/emit or trigger a single REFORGE revision pass.

03 SKILL.md 正文

Verification Methodology

Loaded during the Gate phase. Governs how the Reasoner validates its own reasoning before emitting a verdict.

When to use

Load this skill at the start of Phase G (Gate). Use it to walk the inference chain backward from the verdict for structural defects, build a claim-level evidence coverage matrix, check the decision completeness checklist, derive the 4-factor confidence score (Evidence Quality, Logical Coherence, Constraint Coverage, Sensitivity Analysis), and execute exactly one REFORGE revision pass if the gate fails. Also use it for the Emit phase to build the ECL envelope and persist the verdict via CRYSTALIUM ingest + session_end. Do not use for hypothesis generation (Phase R) or problem decomposition (Phase F).


Gate Dimensions

1. Logical Soundness

Check the reasoning chain for structural defects:

Fallacy Detection Pattern Remedy
Circular reasoning Conclusion appears (rephrased) in premises Trace the inference chain: does each step add new information?
False dichotomy Only 2 options presented when more exist Verify hypothesis count ≥ 3; check for suppressed alternatives
Hasty generalization Conclusion from a single example or narrow evidence Count distinct evidence sources supporting the conclusion
Appeal to authority "X is best because [vendor/expert] says so" Evidence must be functional (why it's best), not reputational
Composition fallacy "Parts are X, therefore whole is X" Check whether the property transfers to the aggregate
Affirming the consequent "If A then B; B is true; therefore A" Verify the causal direction; check for alternative causes
Survivorship bias Only successful cases cited Ask: "What about the cases where this approach failed?"
Ambiguity shift Key term used with different meanings in premises vs conclusion Verify term definitions are stable throughout

Process

Walk the inference chain backward from the verdict:

[VERDICT] ← supported by [Conclusion] ← derived from [Reasoning Step N]
    ← derived from [Reasoning Step N-1] ← ... ← grounded in [Evidence E-ID]

At each step, verify:

  1. Does the step follow from the previous step? (validity)
  2. Is the previous step actually true? (soundness)
  3. Are there hidden premises? Mark as [ASSUMPTION].

Pass condition: No fallacies found. All steps valid and sound (or assumptions explicitly marked).

2. Evidence Coverage

Build a coverage matrix:

| Claim in Verdict | Supporting Evidence | Reliability | Gaps |
|-----------------|-------------------|-------------|------|
| "Redis outperforms Memcached for our use case" | E-2: benchmark data | H | None |
| "Migration can be completed in 2 sprints" | E-5: team velocity | M | [GAP] No similar migration precedent |
| "Operational cost increase is ~$200/mo" | [ASSUMPTION] — based on current pricing | L | [GAP] No formal quote obtained |

Pass condition: Every factual claim has ≥1 evidence anchor. All L-reliability evidence claims carry [ASSUMPTION]. All gaps carry [GAP].

3. Decision Completeness

Verify the verdict answers the framed question:

Checklist Item Pass/Fail
Verdict directly answers the question stated in Frame
All hard constraints addressed with explicit pass/fail
At least 3 alternatives evaluated
Rejected alternatives have stated reasons
Confidence score present with factor breakdown
≥1 [REVERSAL-CONDITION] stated
Handoff recommendations present
Requester can act on this without follow-up clarification

Pass condition: All items pass.


Confidence Calibration Protocol

Confidence is not a feeling. It's a structured assessment across four factors:

Factor 1: Evidence Quality (25%)

Score Criteria
0–25 Mostly L-reliability evidence; multiple critical [GAP]s
26–50 Mix of M and L; some gaps in key areas
51–75 Mostly M-reliability; gaps exist but are non-critical
76–100 Primarily H-reliability; no critical gaps

Factor 2: Logical Coherence (25%)

Score Criteria
0–25 Fallacies detected; inference chain broken
26–50 No fallacies, but multiple [ASSUMPTION] markers in critical path
51–75 Sound reasoning; assumptions present but non-critical
76–100 Air-tight reasoning; minimal assumptions, all well-justified

Factor 3: Constraint Coverage (25%)

Score Criteria
0–25 Hard constraints not fully evaluated
26–50 Hard constraints pass, but soft constraint coverage incomplete
51–75 All constraints evaluated; some soft constraint trade-offs unresolved
76–100 All constraints evaluated with explicit pass/fail and evidence

Factor 4: Sensitivity Analysis (25%)

Score Criteria
0–25 Verdict changes with ±1 on multiple scoring dimensions
26–50 Verdict is sensitive to 1–2 key assumptions
51–75 Verdict is robust to most perturbations; 1 identified sensitivity
76–100 Verdict is robust across all reasonable perturbations

Composite Confidence

Confidence = (EQ × 0.25) + (LC × 0.25) + (CC × 0.25) + (SA × 0.25)

Report both the composite and the individual factors. A high composite with one very low factor is a red flag — call it out.


REFORGE Protocol

When the Gate fails, execute exactly one revision pass:

  1. Identify the specific failures — which dimension(s) failed and why
  2. Target only the failures — do not re-reason the entire deliberation
  3. Mark what changed — annotate revisions so the requester can see what was fixed

What REFORGE may do:

  • Add missing evidence anchors
  • Add [ASSUMPTION] or [GAP] markers to under-supported claims
  • Refine confidence score based on newly identified weaknesses
  • Add a missing alternative or reversal condition

What REFORGE may NOT do:

  • Change the winning hypothesis (if the gate revealed the winner should change, the reasoning was fundamentally flawed — emit with a low confidence and explicit flag)
  • Generate new evidence (the Reasoner doesn't retrieve)
  • Expand scope beyond the framed question

After REFORGE, emit regardless. Flag remaining issues explicitly. The requester needs a verdict, even an imperfect one, more than they need infinite deliberation.


Envelope Construction Checklist (ECL v2.0, v1.3.0+)

When the deliberation was triggered by an incoming reasoning-request envelope, the Emit phase MUST produce both the body file and a sidecar envelope. Run this checklist before emitting:

  1. Compute sha256 of the reasoning-report.md body bytes (lowercase hex, 64 chars).
  2. Inherit thread_id from the inbound reasoning-request envelope — carry it unchanged into the outbound envelope.
  3. Set parent_id to the inbound request's message_id (the UUID from the request envelope, not the thread_id).
  4. Populate context_delta.tokens_used — heuristic chars / 4 is acceptable per ECL §4.2 when exact token counts are unavailable.
  5. Mirror confidence — set envelope.confidence to the composite confidence score from the 4-factor calibration (Evidence quality, Logical coherence, Constraint coverage, Sensitivity analysis), normalised to 0–1.
  6. Select performative: PROPOSE (default), CRITIQUE (REFORGE-reframe path where the question itself is being challenged), INFORM (no-action finding — all options equivalent within constraints).
  7. Append emit trace event to .eidolons/.trace/<thread_id>.jsonl per ECL §5.
  8. Validate the sidecar against schemas/ecl-envelope.v2.json before writing.
  9. Set the ise block — assertion_grade: "self-attested" (ECL v2.0 §6.5; FORGE's Gate is a self-review pass, not an externally spec-mandated check, so self-attested is the honest grade — only a distinct checker per skills/checker-handoff/SKILL.md earns validated), provenance.methodology_version (forge-<version>), and receiver_authorization (auto_route: true, auto_merge: false, auto_deploy: false).
  10. Check the checker-handoff gate — load skills/checker-handoff/SKILL.md and compare the recommended action against its irreversibility trigger table. A match sets the body's requires_checker flag to true; no match leaves it at the default false.

The envelope template is at schemas/reasoning-report.envelope.json.


Provenance Block

Every emitted verdict includes:

## Provenance

- **Decision type**: [type from Frame]
- **Deliberation depth**: [simple/standard/deep] — [N passes executed]
- **Evidence sources**: [count] ([H-count] high, [M-count] medium, [L-count] low reliability)
- **Hypotheses evaluated**: [count]
- **Confidence**: [score]% (Evidence: [X]%, Logic: [X]%, Constraints: [X]%, Sensitivity: [X]%)
- **Gate result**: [PASS / REFORGED — list of fixes]
- **Markers**: [count] ASSUMPTION, [count] GAP, [count] RISK, [count] REVERSAL-CONDITION

CRYSTALIUM Memory Persistence (Emit phase)

After the envelope sidecar is validated (checklist above) and before handing off, persist the reasoning-report to CRYSTALIUM:

Step 1 — Ingest the ECL envelope

mcp__crystalium__ingest(
  envelope = <the validated reasoning-report.envelope.json contents>,
  payload  = <reasoning-report.md contents>
)

This records the verdict at T1 with full ECL provenance (from.eidolon=forge drives tier derivation; integrity.value is stored as provenance.content_hash). Prior verdicts become retrievable by FORGE's Frame-phase recall in future sessions.

Step 2 — Direct episodic notes (optional)

For notable observations from the deliberation not captured in the verdict body (e.g. a recurring constraint pattern, a second-order effect worth tracking):

mcp__crystalium__commit(
  layer      = "episodic",
  payload    = <observation>,
  provenance = { author_agent: "forge", decision_type: <type>, project: <cwd-project> }
)

author_agent MUST be "forge" on every direct commit.

Step 3 — Session end

After ingest (and any optional commits) complete, call:

mcp__crystalium__session_end()

This triggers Dream consolidation asynchronously. Call it once per deliberation completion — not once per pass.

Graceful skip: if mcp__crystalium__* tools are unavailable (CRYSTALIUM not installed), skip all three steps and proceed with the handoff normally. Never hard-fail on absent CRYSTALIUM tools. FORGE is EIIS-standalone-conformant.


Reasoner — Verification Skill

04 同仓库更多 Skills

Rynaro
Rynaro/magicite

wine-dxvk-cache-clear

Clear a stale DXVK shader cache that is causing graphical corruption in a Wine or Proton game. Use when: a game shows corrupted textures or shader flicker that started after a driver or DXVK version change.

★ 2
Rynaro
Rynaro/magicite

steam-download-region-fix

Fix a Steam client stuck at very low download speed by changing its download region. Use when: Steam downloads are far below the local internet speed for every game, not just one.

★ 2
Rynaro
Rynaro/magicite

proton-battleye-eac-toggle

Toggle BattlEye or Easy Anti-Cheat runtime support for a Steam Proton game. Use when: a multiplayer game refuses to launch with an anti-cheat error under Proton.

★ 2
Rynaro
Rynaro/magicite

vivi-verify-incoming

Load when reading any upstream artefact handed off to Vivi that carries a sibling .envelope.json. BLOCKING per ECL §6.2.2: the orchestrator MUST have verified the envelope's SHA-256 (eidolons verify-envelope --block / eidolons run --verify) and recorded a verify_pass before dispatch. If no verify_pass exists for the message_id, or a verify_fail is present, REFUSE to process the payload and hand back to the orchestrator. Symmetric receiver gate — every Eidolon enforces it identically.

★ 2
Rynaro
Rynaro/magicite

vivi-parallel-tracks

Load ONLY under TRANCE authorization when the Plan phase yields N independent, non-overlapping implementation tracks (disjoint file sets). Operationalizes the TRANCE G4 form — parallel multi-track implementation in mandatory git-worktree isolation, max 5 clean-context tracks, a per-track verifier cascade, a non-fungible per-track ≤3 reflection budget, explicit stop conditions, and a single-threaded merge/aggregation step. Absent TRANCE gating, Vivi runs exactly as today: single-track A→P→I→V→Δ/R.

★ 2
Rynaro
Rynaro/magicite

vivi-methodology

Full Vivi cycle reference — A(nalyze) → P(lan) → I(mplement) → V(erify) → Δ(Delta)/R(eflect). Use when the task is a non-trivial feature implementation in a brownfield codebase and you need the complete methodology reference: complexity routing, evidence-grounded planning rules, test-anchoring requirements, and failure-escalation thresholds.

★ 2