verify-bidirectional git:20260717.1ff84b8A

Immutable. This exact content is served forever at /api/v1/blob/d6a983cd7ee2a8f3.

---
name: verify-bidirectional
description: A skill that immediately updates the baseline and reflects it in the next session when the user raises a counter-argument to an AI recommendation. Triggered by "is that right?", "re-examine this", "something seems off here". Explicit /verify-bidirectional call also possible.
user-invocable: true
allowed-tools: ["Read", "Write", "Edit", "Grep", "Glob", "Bash"]
model: sonnet
complexity_routing:
  base: sonnet
  high: opus
  escalate_when:
    - full_revalidation
    - high_stakes
    - fail_verdict   # AI recommendation was wrong → baseline overwrite is high-stakes: at Sonnet, bind the overwrite to a mechanical anchor (diff review + source re-check) and RECOMMEND an opus/sidecar dispatch (consent-gated) — Sonnet+anchor is a legitimate path (sonnet_floor_doctrine.md), silent judged-only overwrite is not
---

# verify-bidirectional — Bidirectional Self-Validation Automation

Automates the processing procedure for bidirectional self-validation. Three stages: user counter-argument → baseline update → next session reflection.

## Trigger Conditions

Immediately **after** this harness AI recommendation/agreement/decision is committed, when the user raises a refinement challenge:

1. **Proposition refinement**: "isn't it more like..." / "I'd say..." / "what about this" / "what's the root?"
2. **Baseline grep trigger**: User cross-references own assets, memory, CLAUDE.md rules, past decisions
3. **Meta-level trigger**: "if you have objections" / "double-check" / "essence" / "root cause"
4. **Side validation result**: User runs independent tools (`/skills` · `gh` · external fetch) → catches mismatch with this harness AI hypothesis

### Natural Language Triggers (works without internal vocabulary)

Also triggered in external user environments by these natural language phrases:

| Phrase | Intent |
|---|---|
| "is that right?", "re-examine this" | Request AI recommendation re-validation |
| "something seems off", "this doesn't feel right" | Counter-argument / refinement |
| "I think you said something different before" | Catch inconsistency with past decisions |
| "can you be more precise?" | Proposition refinement trigger |
| "what's your basis?", "why do you think that?" | Baseline grep trigger |
| "check that one more time" | Self-validation request |

**Exceptions** (this skill does NOT apply):
- Simple user correction ("this is wrong, redo it") = direct negation → immediate correction (no review)
- This harness AI self-catch (no external counter-argument) = `fact-checker` rule (narrow 1 / broad N+1)

## Execution Steps

### Step 1. Immediate Baseline Update Channel Processing

Treat user's statement as **external refinement material**. **Do NOT attempt to defend against it** — acknowledge possibility of partial weakening or correction of initial recommendation.

Core proposition: "refinement challenge ≠ fundamental negation". Priority is identifying where the initial recommendation is weakened.

**Evidence gate (overwrite ≠ soften)** — closes the sycophancy/steering vector where a bare assertion
("that's wrong, re-examine") flips a baseline with zero evidence (judge-robustness swarm, 2026-06-13).
"Do NOT defend" still holds for *this conversation's proposition* (anti-stubbornness is the point), but a
**persistent-baseline overwrite** (a rule, asset, memory, or `knowledge/` claim — anything that outlives
this session) requires a **supporting basis**, not mere pushback:

- **(a)** the user cited a file / line / commit / URL / past decision **and the cited content actually
  supports the challenge** — verified by *reading it*, not by its mere existence (an irrelevant-but-real
  citation is the out-of-context-grounding trap, the same vector phantom-quench guards), **or**
- **(b)** the Step 2 grep returns an actual contradiction that *supports the challenge* (not just any
  conflict with the original) — surfaced literally.

If a baseline overwrite is implied but **neither holds**, do not silently rewrite: verdict is **ESCALATE**
— surface *"this would overwrite baseline {X} with no cited evidence; confirm override, or provide a
source?"* and block the Step 4 cascade until the operator answers. Softening a local in-conversation
proposition (no persistent asset changed) proceeds as before — the gate fires only on persistent-baseline
writes. **Sequencing**: this gate is written in Step 1, but Step 4 is what enumerates affected persistent
assets — so if Step 4 later identifies *any* persistent asset to write, **re-apply this gate before Step
4.5** even if the original challenge first looked like a mere soften. This is **not** restored AI defensiveness: the AI still does not argue the user is wrong; it only
declines to *fabricate a baseline change* the evidence does not support (mirror of the steel-quench/phantom
mechanical-anchor principle — judged verdicts bind to evidence).

### Step 2. Consistency Area Grep (3-step mandatory)

Grep to find which rules, assets, or propositions conflict with the initial recommendation:

**Scope priority**:
1. `memory feedback_*.md` (especially operating model rules — meta principles, warning lines)
2. `CLAUDE.md` Sync/Push Protocol, asset ownership table
3. `tracks/*/learnings/feedback_*.md` — this harness AI's own rules
4. `knowledge/shared/harness-core/*.md` — higher-level framework

**Mandatory grep keywords** (baseline consistency guard):
- "drift" · "asset ownership" (CLAUDE.md)
- Asset names, abbreviations, identifiers explicitly stated in user's message

**External users**: Replace with your own environment's baseline keywords (prioritize asset names, abbreviations, identifiers from user's message).

### Step 3. Fact-Checker Self-Catch Mark

Mark the corrected weakened proposition as a fact-checker self-catch:

```
fact-checker self-catch #N (narrow 1 / broad N+1)
- This harness AI initial recommendation: {summary}
- Refinement challenge: {user's statement}
- Corrected recovery: {updated proposition}
- Consistency rule: {grep result}
```

### Step 4. Immediate Patch (Cascading Update Obligation)

First identify the list of affected assets. Actual file modification is performed after user approval in Step 4.5.

| Affected Asset | Update Location | Notes |
|---|---|---|
| memory `feedback_bidirectional_self_validation.md` | Add cumulative count + new round table | Self-perpetuation of this rule |
| memory `project_*.md` (if affected) | Add relevant section | When naming, identity, or roadmap changes |
| `tracks/_audit/*.md` (if affected) | Add pre-design section | When this validation affects persistent assets |
| `CATALOG.md` | Add this session entry | For major decisions |
| `reference_next_session_starter.md` §1 | Merge this conclusion | Material for next session entry |

**Markdown editing discipline** (`feedback_markdown_edit_discipline`): Use Edit for existing `.md`. Write prohibited. If unavoidable, verify immediately with `git diff`.

### Step 4.5. Change `diff` Review (User Gate Required)

For each 'affected asset' identified in Step 4, the AI generates a `diff` of the proposed changes and presents it to the user.

```
⚠ Proposed automatic modifications to the following files.
File: {file path}
--- diff
(changes in git diff format)
---
Would you like to apply these changes? [y / N]
```

`y` = execute actual file modification (`Edit` or `Write`). `N` = skip that file change. Must receive `y` or `N` for every change proposal before proceeding. This ensures the Human-in-the-loop principle and minimizes risks from automatic AI modifications.

### Step 5. Compatibility Enhancement Area Identification (Optional)

Refinement challenge ≠ fundamental negation. When a **compatibility enhancement area** is identified (part of initial recommendation + part of refinement = integrated proposition), add 1 explicit statement:

4 refinement challenge patterns:
1. **Compatibility enhancement** — two propositions coexist (e.g., "AI data processing + human baseline validation")
2. **Time-bounded** — proposition is time-bounded (e.g., "Phase II alignment / re-validate in Phase III")
3. **Naming intent verification** — naming itself divides intent (e.g., "bottleneck = efficiency measure vs. negating humanity")
4. **N-way condition** — proposition only holds under N conditions (e.g., "recipient's learning intent + gap separation + resource constraint awareness")

Skip this step if no compatibility enhancement found (no token-filler).

### Step 6. Update Trigger Count + Skill Update Review

Update trigger count in `memory feedback_bidirectional_self_validation.md`:

- 5+ accumulated = Skill promotion review (already fulfilled by creating this skill ✅)
- 8+ accumulated = skill update review (rule refinement + round table compression + update this skill)
- When user names a refinement challenge pattern (bidirectional evolution dimension documentation)
- When this harness AI identifies its own baseline grep omission pattern (add new initial recommendation consistency guard)

## Self-Activation Channel — Autonomous Baseline Cross-Check

This skill's essence = user ↔ this harness AI bidirectional self-validation. This section = active channel where the AI runs autonomous baseline grep without user mediation.

### Activation Triggers (autonomous mode)

- **Natural cadence**: weekly_audit 7-day cycle (when `harvest-loop` skill runs) → AI runs autonomous baseline grep
- **External asset persona audit time**: After updating externally-published asset, call `hub-persona-auditor` agent → mandatory processing on REVISE verdict
- **User explicitly grants autonomy**: "let's go in order" / "go ahead" patterns → AI granted autonomous execution permission

### Limits

- **Explicit user direction required** — AI cannot decide alone. Without explicit direction, autonomous activation only on natural cadence arrival
- **Simplification guard compliance** — if 5+ new assets accumulate from autonomous run, archive decision is mandatory
- **Only AI self-catches count for fact-checker** — this channel is a supplementary axis, not the primary bidirectional validation axis

## Proactive Concern Channel

This skill's existing flow = **reactive** — user refinement challenge → AI baseline update.
**Active** addition — AI proactively speaks up about premise errors or directional risks without user asking.

Background: If the user proceeds without detecting a wrong direction or without being able to express doubt, it comes back at a much greater cost later. Waiting for the back-and-forth build-up transfers the responsibility of detecting premise errors to the user.

### Activation Conditions

Speak up **before** entering implementation if any of these apply:

1. User presents a new direction/frame/premise — conflicts with existing assets, baseline, or simplification guard
2. Gap detected between surface purpose (what user is asking for) and actual problem being solved (root)
3. Agent/model delegation is clearly cost-ineffective

### Message Format

```
"Before going in [direction/premise] direction, one concern: [concern].
 Reason: [basis — existing baseline/asset name or root logic].
 Should we proceed, or review another approach first?"
```

### Constraints

- **One concern only** — listing multiple concerns creates hurdles (increases user cognitive load)
- **Only before implementation starts** — braking on work already in progress destroys context
- **If user explicitly says "just go"** — skip proactive message and execute immediately
- If user listens to concern and decides "let's proceed anyway", execute immediately instead of reactive 6-step

## User Approval Gates

| Stage | Approval |
|---|---|
| Step 4.5 change `diff` review | **Required** |
| Step 4 major decision cascading (CATALOG · external asset impact) | **Required** |
| Step 6 skill update review | **Required** |

## Constraints

- **This skill = validation and recording automation. Core decisions belong to the user** — this harness AI has no independent decision authority
- **This harness AI self-catch cannot be applied alone** — follow `fact-checker` rule (narrow 1 / broad N+1)
- **Simplification guard compliance** (`feedback_simplification_evidence`) — when creating/modifying this skill, only update SKILL.md. Do not create additional auxiliary files
- **Markdown editing discipline obligation** (`feedback_markdown_edit_discipline`) — prefer Edit. Write prohibited

## External User Environment Adaptation

This skill's core essence = "channel for updating baseline when user refinement challenge occurs after AI recommendation/agreement is committed" — cross-applicable to all user environments.

### Fallback Matrix (origin environment → external environment replacement)

| Origin Environment Dependency | External User Environment Fallback |
|---|---|
| `memory feedback_bidirectional_self_validation.md` (rule body) | User environment's own `memory/` or `notes/` bidirectional validation rule / if absent, follow this skill's own rule baseline |
| `memory feedback_*.md` grep scope (Step 2 priority 1) | User environment's own `learnings/` · `docs/` · `CLAUDE.md` grep (user's own baseline) |
| `tracks/*/learnings/feedback_*.md` (Step 2 priority 2) | User environment's own learnings area (auto-detect naming variations) |
| `knowledge/shared/harness-core/*.md` (Step 2 priority 4) | User environment's own `docs/` or `knowledge/` grep |
| `CATALOG.md` entry addition (Step 4) | User environment's own history archive (skip if absent) |
| `reference_next_session_starter.md §1` (Step 4) | User environment's own next-session material (skip if absent) |
| Mandatory grep keywords ("drift", asset ownership, etc.) | User environment's own baseline keywords (prioritize asset names, abbreviations, identifiers from user's message) |

### External User Scenarios

1. **General bidirectional validation**: AI recommendation → user refinement challenge → this skill auto-activates → 6-step processing (Step 1 immediate baseline update / Step 2 consistency grep / Step 3 fact-checker self-catch / Step 4 immediate patch / Step 4.5 diff gate / Step 5 compatibility enhancement / Step 6 update trigger count)
2. **User's own baseline cross-ref**: Generalize Step 2 grep scope to user environment's own assets
3. **Fact-checker count generalization**: Start user's own self-catch count from 0 (narrow 1 / broad N+1)
4. **Same user approval gate**: Step 4.5 diff review / Step 4 major decision cascading / Step 6 Skill v0.x update

### Limits

- **External users can use their own model cross-check channel** (e.g., other LLM API, other in-house model)
- **Accumulated validation history** = accumulates from origin for the original developer / external users start their own count from 0
- **Autonomous activation baseline examples** (harvest-loop + hub-persona-auditor) = origin environment baseline / external users can also trigger autonomous activation on their own natural cadence
- External users also follow same user approval gate (Human-in-the-loop principle baseline)

## Done When

```
Steps 1~6 all executed
+ fact-checker self-catch mark output
+ Step 4.5 diff gate user confirmation complete (y/N response received)
+ Update trigger count updated
+ External validation path: harvest-loop's Critic isolation pass (SAGE automated critique) can independently judge based on above criteria (skill_quality_rubric.md verifiable criteria)
```

Verdict: PASS (Step 4.5 diff gate confirmed, baseline updated) | CONDITIONAL_PASS (update applied, external validation still pending) | FAIL (counter-argument confirmed — AI recommendation was wrong, baseline requires redesign) | ESCALATE (counter-argument ambiguous, human judgment required)

## References

- Rule body: `memory feedback_bidirectional_self_validation.md`
- Operating model text: `memory feedback_hub_cc_operating_model.md §2.5·§2.6` — Insight 5 meta dimension + refinement challenge 4 patterns
- Consistency rules: `feedback_external_ai_github_recommendation_verification` · `feedback_reference_own_hub_assets_first` · `feedback_simplification_evidence` · `feedback_markdown_edit_discipline` · `feedback_impact_first_then_tune`