Claude opencode Skill

validate

Freshly judge a finished change against its acceptance: PASS, FAIL, or NOT_PROVEN. Not for claim-vs-tree checks; that is reality-check. Triggers: "validate", "is this proven", "check this change", "cross-model review".

LLM Mart · 0 points · 11 views 0 listing impressions 0 install-command copies
Download boshu2-agentops-skills_validate-596942d.zip · 34 KB

Install

skills CLI npx skills add https://github.com/boshu2/agentops/tree/main/skills/validate
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install boshu2-agentops@llmmart
Git git clone https://github.com/boshu2/agentops.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole boshu2/agentops collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Validate

From a context that did not author it, judge one finished candidate against its original acceptance and return PASS, FAIL, or NOT_PROVEN with evidence for each criterion. The author's word is a claim, every criterion needs its own evidence, and green obtained by weakening a check is FAIL.

Use instead When
Review advice or a second look
Research whether a stated claim holds

This file carries every rule the judgment needs. Linked files, including RPI boundaries and mechanics, add depth only: if one cannot be read, judge from this file and say which was unavailable.

Rules that decide the verdict

  • The author cannot issue a binding PASS, and advisory findings, such as a Review or Council report, cannot stand in for this judgment: test them as claims. An author's summary, confidence or assurance is a claim to check, not evidence; explanation alone is not proof.
  • Each criterion needs its own evidence on the exact candidate. A criterion nobody demonstrated goes in not_checked and never counts toward PASS.
  • A changed test, tolerance, golden, suppression or acceptance text must still satisfy the original intent. Green obtained by weakening the oracle is FAIL for the criterion it was meant to prove, and that green is not evidence. The same holds for green obtained by changing what the check runs against: product code that behaves differently when it detects a test or CI environment, a failure path newly silenced by an empty handler or discarded error, or a check made non-blocking, skipped or bypassed. Each needs a reason visible in the change that still serves the original intent.
  • A receipt is check output tied to this subject: command, result, and commit SHA or digest; a summary such as "suite is green" is a claim. Read receipts; do not re-run checks the author ran on this exact subject or that CI will run. Re-execute only a risk-critical claim that has no receipt.
  • A necessary finding never becomes an optional caveat or non-goal.

Decide in this order:

  1. The subject changed during judgment, changed-path coverage is incomplete, or author and validator identity or freshness is missing, colliding or unattested: NOT_PROVEN.
  2. A criterion is proven failed, or a change is proven out of scope: FAIL, even when other criteria are unverified.
  3. Any in-scope criterion lacks evidence: NOT_PROVEN.
  4. Every criterion is verified with evidence, checked scope is nonempty and not_checked is empty: PASS.

Establish intent first

An explicit request for Validate, an acceptance verdict or independent proof that original acceptance is met selects this skill, even when phrased as "review this"; a request for a look or opinion goes to Review, and when the purpose is open, ask once and issue no verdict meanwhile, since missing intent is not a NOT_PROVEN verdict (advice or acceptance).

When a fresh judgment is worth it

Spend validation where a mistake is costly. For an ordinary change the author's checks and CI are the gate, and no fresh judgment is owed. Use Validate when:

  • the caller asks for an acceptance verdict or independent proof;
  • a mistake cannot be cheaply undone after it lands: a published release or instructions users will follow, a security boundary, destroying data or tracker state, deleting a check that protects the product; or
  • no deterministic check covers the behavior that changed.

Judge once. Report NOT_PROVEN with its gaps and stop; do not request or wait for another round. The author repairs findings and the checks that cover each repair confirm it; a repair does not start a second judgment. Keep the judgment's cost a fraction of the cost of the work: when it approaches that cost, stop and return what is unchecked.

Subject

The subject is a nonempty implementation candidate, held unchanged after required checks and known repairs; plans, audits and reviews are subjects only when the caller requested document review. Supplied failed-acceptance evidence proves a failure on that subject: FAIL, unless a step 1 gap makes it NOT_PROVEN; do not review a moving repair. Bind its identity at the start and again at the end of judgment:

  • With AgentOps installed: ao provenance manifest --root "$REPO_ROOT" --include "$CHANGED_PATH", one --include per changed path (helper commands). A deleted path is bound only with --base-manifest <base-manifest>; without a base manifest, use the Git fallback below.
  • In any Git repository: the commit SHA (git rev-parse HEAD) and the changed paths (git diff --name-only <base>...HEAD); for uncommitted work, the git status --porcelain listing and a shasum -a 256 of each changed file.
  • A subject supplied only in the conversation, such as a pasted diff or a described change, is exactly what was supplied, so its coverage is complete as supplied; anything it does not show is unverified.

Identity and freshness

Author and validator identities must be explicit and distinct, and freshness attested by the runtime or the caller, naming the attester; an attestation is a declared trust fact, not cryptographic isolation. In ordinary use these count:

  • Author: the identity the caller gives for whoever produced the candidate: a person, a session or agent ID, or the commit author.
  • Validator: this context's runtime ID, such as a subagent or session ID; otherwise the dispatcher's handle for it, such as the agent ID returned at launch, or "this conversation" when the caller opened it for the judgment.
  • Freshness: a statement, naming who makes it, that this context did not produce the candidate and was given intent, subject and evidence rather than the author's working history. When the caller opened this conversation for the judgment and supplied the candidate, the caller is the attester.

A role name, a persona switch inside the author's conversation, or the validator vouching for itself does not count. Never invent an identity. An identity gap makes the result NOT_PROVEN; keep every finding in the report.

Reviewers

Default to one fresh reviewer in the author's model family (Codex/OpenAI for Codex/OpenAI, Claude/Anthropic for Claude/Anthropic), on the runtime's configured capable model unless pinned. If this context produced the candidate, it cannot be that reviewer: dispatch one and return its result, or return NOT_PROVEN with the identity gap when none can run. Give the reviewer intent, scope, exact subject, the evidence each criterion needs and one question written before it starts, never full author history, the author's confidence, a desired verdict or peer conclusions.

When the caller selects a cross-model leg, read cross-model legs before dispatching it. The rules for choosing and pinning that leg's model are in model dispatch. When a caller requires proof of which context judged, open judgment receipts before recording evidence_refs. Respect real caller and native time bounds without renewing them; a timeout is missing judgment, not FAIL.

Judgment

  1. Bind the subject. Verify continuity with the exact caller-owned intent, cited evidence and complete changed-path coverage; missing integrity is NOT_PROVEN.
  2. Revisit the original accepted behavior examples, including those in the conversation or bead, and check each observable result and its domain meaning on the exact candidate. A new test or renamed concept cannot replace an unfulfilled scenario. Inspect the actual diff against every criterion; publication or provenance claims in docs need verifiable evidence too. Risk sets depth: acceptance, permissions, tests and gates, stopping, disclosure, hooks and executable controls warrant deeper reading, including prose policy. Unknown risk merits examination, not extra reviewers.
  3. Classify commands before running any. Regeneration, synchronization, formatting and --force mutate the subject until proven otherwise; run them only on a disposable copy, such as a fresh worktree or clone at the committed SHA, never the judged checkout.
  4. Bind the subject again; a mismatch is NOT_PROVEN.
  5. Return one result in the shape below, promptly, and stop.

Report

Verdict: PASS | FAIL | NOT_PROVEN
Subject: <manifest digest, or commit SHA and changed paths>; unchanged start to end: yes | no
Criteria:
  1. <criterion> - verified | failed | not verified - <evidence: file:line, receipt, observed output>
Findings: <class> - <what and where> - <consequence>   (or "none")
Notes (optional, do not change the verdict): <...>
Checked: <what was inspected, and how>
Not checked: <in-scope acceptance not verified>   (empty only for PASS)
Identity: author <id>; validator <id>; freshness attested by <runtime | caller>: <attester>

The judgment worked when every criterion shows its own evidence or sits under Not checked, the subject line names what was judged and whether it stayed unchanged, and a PASS has an empty Not checked.

A finding fails an acceptance criterion or would mislead a user, break install or the CLI, or remove protection for the product; anything else is an optional note the author may ignore. Give each finding a short class and say whether it is pre-existing, introduced or unknown from before/after evidence; counts and timestamps alone do not establish cause. not_checked holds in-scope acceptance that was not verified, including delivery inside acceptance whose evidence does not yet exist; never remove a criterion or hide a limit to reach PASS. Other limits stay in criterion reasoning, declared non-goals or residual-risk prose (homes).

Validate is the sole semantic author of verdict.v2. Only when the caller requests machine-readable evidence or a declared consumer requires it, persist through ao provenance store-verdict (draft shape); Go verifies structure and storage, not truth. Otherwise return the result through the caller's channel, without hidden machine artifacts. Validate owns no repair, retry, delivery or tracker transition: findings go back to the author for direct repair, and a causal stall gets at most one bounded fresh helper (RPI).

Files (agentops)
  • references
    • judgment-receipts.md 6.5 KB
      Loading…
    • mechanics.md 9 KB
      Loading…
    • model-dispatch.md 10.4 KB
      Loading…
    • validate.feature 1.6 KB · in bundle
  • tests
    • check_contract_corpus.py 5.4 KB
      Loading…
    • test_evidence_cli.py 14 KB
      Loading…
    • test_validate.py 15.8 KB
      Loading…
    • validate.py 29 KB
      Loading…
    • validate.sh 745 B
      Loading…
  • SKILL.md 11.4 KB
    ---
    name: validate
    description: 'Freshly judge whether a finished change and its claims meet original acceptance: PASS, FAIL or NOT_PROVEN. Use when: asked for a go/no-go, sign-off or independent verdict.'
    practices:
    - design-by-contract
    - llm-eval-harness
    - content-addressed-storage
    hexagonal_role: driving-adapter
    consumes:
    - subject-manifest.v1
    produces:
    - subject-manifest.v1
    - validation-result
    - verdict.v2
    context_rel:
    - kind: customer-of
      with: plan
    - kind: customer-of
      with: implement
    skill_api_version: 1
    user-invocable: true
    metadata:
      graph_root: true
      tier: judgment
      dependencies: []
      capabilities: [compute_subject_identity, judge_acceptance, return_validation_result, persist_verdict]
      effects: [write_verdict_artifact]
      canonical_status: canonical
      disposition: keep
    output_contract: 'PASS | FAIL | NOT_PROVEN with criteria, evidence, checked/not_checked, identity, and freshness; optional verdict.v2 persistence (draft shape in references/mechanics.md)'
    ---
    
    # Validate
    
    From a context that did not author it, judge one finished candidate against
    its original acceptance and return `PASS`, `FAIL`, or `NOT_PROVEN` with
    evidence for each criterion. The author's word is a claim, every criterion
    needs its own evidence, and green obtained by weakening a check is FAIL.
    
    | Use instead | When |
    |---|---|
    | [Review](../review/SKILL.md) | advice or a second look |
    | [Research](../research/SKILL.md#claimed-state-audit) | whether a stated claim holds |
    
    This file carries every rule the judgment needs. Linked files, including
    [RPI boundaries](../rpi/references/boundaries.md) and
    [mechanics](references/mechanics.md), add depth only: if one cannot be read,
    judge from this file and say which was unavailable.
    
    ## Rules that decide the verdict
    
    - The author cannot issue a binding PASS, and advisory findings, such as a
      Review or Council report, cannot stand in for this judgment: test them as
      claims. An author's summary, confidence or assurance is a claim to check,
      not evidence; explanation alone is not proof.
    - Each criterion needs its own evidence on the exact candidate. A criterion
      nobody demonstrated goes in `not_checked` and never counts toward PASS.
    - A changed test, tolerance, golden, suppression or acceptance text must still
      satisfy the original intent. Green obtained by weakening the oracle is FAIL
      for the criterion it was meant to prove, and that green is not evidence.
      The same holds for green obtained by changing what the check runs against:
      product code that behaves differently when it detects a test or CI
      environment, a failure path newly silenced by an empty handler or discarded
      error, or a check made non-blocking, skipped or bypassed. Each needs a reason
      visible in the change that still serves the original intent.
    - A receipt is check output tied to this subject: command, result, and commit
      SHA or digest; a summary such as "suite is green" is a claim. Read receipts;
      do not re-run checks the author ran on this exact subject or that CI will
      run. Re-execute only a risk-critical claim that has no receipt.
    - A necessary finding never becomes an optional caveat or non-goal.
    
    Decide in this order:
    
    1. The subject changed during judgment, changed-path coverage is incomplete,
       or author and validator identity or freshness is missing, colliding or
       unattested: NOT_PROVEN.
    2. A criterion is proven failed, or a change is proven out of scope: FAIL, even
       when other criteria are unverified.
    3. Any in-scope criterion lacks evidence: NOT_PROVEN.
    4. Every criterion is verified with evidence, checked scope is nonempty and
       `not_checked` is empty: PASS.
    
    ## Establish intent first
    
    An explicit request for Validate, an acceptance verdict or independent proof
    that original acceptance is met selects this skill, even when phrased as
    "review this"; a request for a look or opinion goes to Review, and when the
    purpose is open, ask once and issue no verdict meanwhile, since missing intent
    is not a `NOT_PROVEN` verdict
    ([advice or acceptance](../review/references/advice-or-acceptance.md#ambiguous-requests)).
    
    ## When a fresh judgment is worth it
    
    Spend validation where a mistake is costly. For an ordinary change the author's
    checks and CI are the gate, and no fresh judgment is owed. Use Validate when:
    
    - the caller asks for an acceptance verdict or independent proof;
    - a mistake cannot be cheaply undone after it lands: a published release or
      instructions users will follow, a security boundary, destroying data or
      tracker state, deleting a check that protects the product; or
    - no deterministic check covers the behavior that changed.
    
    Judge once. Report NOT_PROVEN with its gaps and stop; do not request or wait
    for another round. The author repairs findings and the checks that cover each
    repair confirm it; a repair does not start a second judgment. Keep the
    judgment's cost a fraction of the cost of the work: when it approaches that
    cost, stop and return what is unchecked.
    
    ## Subject
    
    The subject is a nonempty implementation candidate, held unchanged after
    required checks and known repairs; plans, audits and reviews are subjects only
    when the caller requested document review. Supplied failed-acceptance evidence
    proves a failure on that subject: FAIL, unless a step 1 gap makes it
    NOT_PROVEN; do not review a moving repair. Bind its identity at the start and
    again at the end of judgment:
    
    - With AgentOps installed: `ao provenance manifest --root "$REPO_ROOT" --include "$CHANGED_PATH"`,
      one `--include` per changed path ([helper commands](references/mechanics.md#helper-commands)).
      A deleted path is bound only with `--base-manifest <base-manifest>`; without
      a base manifest, use the Git fallback below.
    - In any Git repository: the commit SHA (`git rev-parse HEAD`) and the changed
      paths (`git diff --name-only <base>...HEAD`); for uncommitted work, the
      `git status --porcelain` listing and a `shasum -a 256` of each changed file.
    - A subject supplied only in the conversation, such as a pasted diff or a
      described change, is exactly what was supplied, so its coverage is complete
      as supplied; anything it does not show is unverified.
    
    ## Identity and freshness
    
    Author and validator identities must be explicit and distinct, and freshness
    attested by the runtime or the caller, naming the attester; an attestation is
    a declared trust fact, not cryptographic isolation. In ordinary use these count:
    
    - **Author:** the identity the caller gives for whoever produced the candidate:
      a person, a session or agent ID, or the commit author.
    - **Validator:** this context's runtime ID, such as a subagent or session ID;
      otherwise the dispatcher's handle for it, such as the agent ID returned at
      launch, or "this conversation" when the caller opened it for the judgment.
    - **Freshness:** a statement, naming who makes it, that this context did not
      produce the candidate and was given intent, subject and evidence rather than
      the author's working history. When the caller opened this conversation for
      the judgment and supplied the candidate, the caller is the attester.
    
    A role name, a persona switch inside the author's conversation, or the
    validator vouching for itself does not count. Never invent an identity. An
    identity gap makes the result NOT_PROVEN; keep every finding in the report.
    
    ## Reviewers
    
    Default to one fresh reviewer in the author's model family (Codex/OpenAI for
    Codex/OpenAI, Claude/Anthropic for Claude/Anthropic), on the runtime's
    configured capable model unless pinned. If this context produced the
    candidate, it cannot be that reviewer: dispatch one and return its result, or
    return NOT_PROVEN with the identity gap when none can run. Give the reviewer
    intent, scope, exact subject, the evidence each criterion needs and one
    question written before it starts, never full author history, the author's
    confidence, a desired verdict or peer conclusions.
    
    When the caller selects a cross-model leg, read
    [cross-model legs](references/mechanics.md#cross-model-legs) before
    dispatching it. The rules for choosing and pinning that leg's
    model are in [model dispatch](references/model-dispatch.md). When a caller
    requires proof of which context judged, open
    [judgment receipts](references/judgment-receipts.md) before recording
    `evidence_refs`. Respect real caller and native time bounds without renewing
    them; a timeout is missing judgment, not FAIL.
    
    ## Judgment
    
    1. Bind the subject. Verify continuity with the exact caller-owned intent,
       cited evidence and complete changed-path coverage; missing integrity is
       NOT_PROVEN.
    2. Revisit the original accepted behavior examples, including those in the
       conversation or bead, and check each observable result and its domain
       meaning on the exact candidate. A new test or renamed concept cannot replace
       an unfulfilled scenario. Inspect the actual diff against every criterion;
       publication or provenance claims in docs need verifiable evidence too. Risk
       sets depth: acceptance, permissions, tests and gates, stopping, disclosure,
       hooks and executable controls warrant deeper reading, including prose
       policy. Unknown risk merits examination, not extra reviewers.
    3. Classify commands before running any. Regeneration, synchronization,
       formatting and `--force` mutate the subject until proven otherwise; run them
       only on a disposable copy, such as a fresh worktree or clone at the committed
       SHA, never the judged checkout.
    4. Bind the subject again; a mismatch is NOT_PROVEN.
    5. Return one result in the shape below, promptly, and stop.
    
    ## Report
    
    ```text
    Verdict: PASS | FAIL | NOT_PROVEN
    Subject: <manifest digest, or commit SHA and changed paths>; unchanged start to end: yes | no
    Criteria:
      1. <criterion> - verified | failed | not verified - <evidence: file:line, receipt, observed output>
    Findings: <class> - <what and where> - <consequence>   (or "none")
    Notes (optional, do not change the verdict): <...>
    Checked: <what was inspected, and how>
    Not checked: <in-scope acceptance not verified>   (empty only for PASS)
    Identity: author <id>; validator <id>; freshness attested by <runtime | caller>: <attester>
    ```
    
    The judgment worked when every criterion shows its own evidence or sits under
    `Not checked`, the subject line names what was judged and whether it stayed
    unchanged, and a PASS has an empty `Not checked`.
    
    A finding fails an acceptance criterion or would mislead a user, break install
    or the CLI, or remove protection for the product; anything else is an optional
    note the author may ignore. Give each finding a short `class` and say whether
    it is pre-existing, introduced or unknown from before/after evidence; counts
    and timestamps alone do not establish cause. `not_checked` holds in-scope acceptance that was
    not verified, including delivery inside acceptance whose evidence does not yet
    exist; never remove a criterion or hide a limit to reach PASS. Other limits
    stay in criterion reasoning, declared non-goals or residual-risk prose
    ([homes](references/mechanics.md#where-each-scope-limit-lives-inside-a-pass)).
    
    Validate is the sole semantic author of `verdict.v2`.
    Only when the caller requests machine-readable evidence or a declared consumer
    requires it, persist through `ao provenance store-verdict`
    ([draft shape](references/mechanics.md#store-verdict-draft)); Go verifies
    structure and storage, not truth. Otherwise return the result through the
    caller's channel, without hidden machine artifacts. Validate owns no repair,
    retry, delivery or tracker transition: findings go back to the author for
    direct repair, and a causal stall gets at most one bounded fresh helper
    ([RPI](../rpi/references/boundaries.md#direct-repair-and-help)).
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.