Install

npm install @reshimu/shor

yarn add @reshimu/shor

pip install reshimu-shor

No native dependencies. No compilation step. Works in any Node.js ≥ 18 or Python ≥ 3.9 runtime.

Quick start

TypeScript / JavaScript

import { classify } from '@reshimu/shor'

const result = classify({
  output: "The meeting was scheduled for Thursday at 2pm in Conference Room B.",
  sources: [
    "Per the invite, the sync is Thursday 2:00 PM, CR-B.",
    "Attendees: Priya, Marcus, Leila."
  ]
})

console.log(result.level)      // 'GROUNDED'
console.log(result.score)      // 0.94
console.log(result.unmatched)  // []

Partial grounding

const result = classify({
  output: "The Q3 revenue was $4.2M, up 18% from Q2.",
  sources: [
    "Q3 revenue: $4.2M."
    // No Q2 comparison in source material
  ]
})

console.log(result.level)      // 'PARTIAL'
console.log(result.unmatched)  // ['up 18% from Q2']

Python

from reshimu_shor import classify

result = classify(
    output="The patient was prescribed 500mg twice daily.",
    sources=[
        "Dosage: 500mg BID.",
        "Medication: amoxicillin."
    ]
)

print(result.level)      # 'GROUNDED'
print(result.score)      # 0.97
print(result.unmatched)  # []

Classification levels

API reference

classify(options)

Parameters:

Returns:

Integration guide

SHOR sits between an agent's output and any downstream action that depends on it. The pattern is consistent regardless of orchestration framework.

import { classify } from '@reshimu/shor'

async function agentAction(agentOutput: string, sourceContext: string[]) {
  const grounding = classify({ output: agentOutput, sources: sourceContext })

  if (grounding.level === 'UNGROUNDED') {
    return {
      blocked: true,
      reason: 'ungrounded output',
      unmatched: grounding.unmatched
    }
  }

  if (grounding.level === 'PARTIAL') {
    // Log and escalate, or continue with reduced-trust flag
    console.warn('Partial grounding. Unmatched:', grounding.unmatched)
  }

  return { blocked: false, output: agentOutput }
}

With NESHER (irreversibility gate)

SHOR and NESHER compose. The recommended order is: classify the action's reversibility first (NESHER), then check grounding of the output that produced it (SHOR). This way, an UNGROUNDED output cannot propose an irreversible action without both gates flagging.

import { classify as grounding } from '@reshimu/shor'
import { classify as reversibility } from '@reshimu/nesher'

async function intercept(action: string, output: string, sources: string[]) {
  const rev  = reversibility({ action, target: output })
  const gnd  = grounding({ output, sources })

  if (rev.level === 'CRITICAL' || gnd.level === 'UNGROUNDED') {
    return { blocked: true, rev, gnd }
  }

  return { blocked: false, rev, gnd }
}

Python agent loop

from reshimu_shor import classify

def before_tool_call(output: str, sources: list[str]) -> dict:
    result = classify(output=output, sources=sources)

    if result.level == "UNGROUNDED":
        raise ValueError(f"Blocked: ungrounded output. Unmatched: {result.unmatched}")

    return {"level": result.level, "score": result.score}

Design constraints

For the full reasoning behind the no-LLM constraint, see Why we don't trust LLMs to classify the call they're about to make.

Runtime stack

SHOR is the second of four runtime integrity validators — the Chayyot — that form the Reshimu agent governance stack.

Each validator is a zero-dependency library, usable independently. The Atzmut OS MCP server integrates all four into a single intercept layer.

For the architectural pattern underlying all four, see Bearers of the Throne.