oh-my-harness 0.24.0 → 0.25.0

package/README.md

@@ -105,6 +105,24 @@ omh init "Next.js + FastAPI, TDD enforced, no auto PRs"
 
 The always-on guards (harness self-protection, `--no-verify`, force-push) are added to every preset and every Jev result.
 
+### Rules that enforce themselves
+
+Two fields on a rule in `harness.yaml` turn prose into a check:
+
+```yaml
+rules:
+  - id: no-deps
+    title: No new dependencies
+    content: Do not add npm dependencies without asking.
+    enforce: true          # every Bash/Edit/Write call is judged against this rule by Jev
+  - id: no-secrets
+    title: No secrets in code
+    content: Never commit tokens or passwords.
+    lint: hardcodes a secret, token or password   # the staged diff is linted with jgrep before commit
+```
+
+`enforce: true` adds `semantic-rule-guard`: one Jev question per enforced rule per tool call, block at p ≥ 0.9, ask between 0.6 and 0.9, allow below; without a key, or on an API error, it allows and logs `skipped`. `lint:` adds `semantic-diff-gate`, which runs `jgrep --diff --staged "<description>"` and blocks the commit on a hit with `file:line`. When the same command also stages (`git add … && git commit`, `git commit -a`), the gate previews the index that command would build, so nothing slips through because it was not staged yet. jgrep is optional: `npm i -g jevgrep && jgrep init`; the `strict` preset adds three generic lints when `omh init` finds it. Both layers are additive and never relax a deterministic guard.
+
 ---
 
 ## 🧱 Building Block Catalog
@@ -122,6 +140,8 @@ All enforcement is powered by **catalog blocks** — reusable, parameterized hoo
 | 💥 `force-push-guard` | git | Blocks force pushes to protected branches (always on) |
 | 🛑 `stop-test-gate` | quality | When the agent tries to end its turn with failing tests, sends it back (retry-capped) |
 | 📝 `stop-uncommitted-warn` | git | Lists uncommitted changes as a system message when the turn ends |
+| 🧠 `semantic-rule-guard` | security | Rules marked `enforce: true` are judged by Jev on every Bash/Edit/Write call |
+| 🔎 `semantic-diff-gate` | quality | Lints the staged diff with [jgrep](https://github.com/kyu1204/jgrep) against `lint:` rule descriptions before commit (optional) |
 | 📁 `path-guard` | file-protection | Blocks writes to protected paths |
 | 🔐 `lockfile-guard` | file-protection | Prevents manual lockfile edits |
 | 🤫 `secret-file-guard` | security | Blocks edits to .env, credentials |

package/dist/catalog/blocks/branch-guard.js

@@ -33,7 +33,7 @@ if _omh_cmd_matches "$COMMAND" git commit || _omh_cmd_matches "$COMMAND" git pus
       if ($i != "git") next
       c = cwd; ex = 0; j = i + 1
       while (j <= NF && $j ~ /^-/) {
-        if ($j == "-C") { if ($(j + 1) ~ /^\\//) ex = 1; c = omh_cd(c, $(j + 1), home); j++ }
+        if ($j == "-C") { if ($(j + 1) ~ /^(\\/|~\\/)/) ex = 1; c = omh_cd(c, $(j + 1), home); j++ }
         else if ($j == "-c") j++
         j++
       }

package/dist/catalog/blocks/index.js

@@ -21,6 +21,8 @@ import { noVerifyGuard } from "./no-verify-guard.js";
 import { forcePushGuard } from "./force-push-guard.js";
 import { stopTestGate } from "./stop-test-gate.js";
 import { stopUncommittedWarn } from "./stop-uncommitted-warn.js";
+import { semanticRuleGuard } from "./semantic-rule-guard.js";
+import { semanticDiffGate } from "./semantic-diff-gate.js";
 export const builtinBlocks = [
     branchGuard,
     commitTestGate,
@@ -45,4 +47,6 @@ export const builtinBlocks = [
     forcePushGuard,
     stopTestGate,
     stopUncommittedWarn,
+    semanticRuleGuard,
+    semanticDiffGate,
 ];

package/dist/catalog/blocks/semantic-diff-gate.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const semanticDiffGate: BuildingBlock;

package/dist/catalog/blocks/semantic-diff-gate.js

@@ -0,0 +1,118 @@
+// Semantic lint of the staged diff before a commit (#145), powered by jgrep
+// (https://github.com/kyu1204/jgrep): `jgrep --json --diff --staged "<rule>"`
+// asks Jev, hunk by hunk, whether the change does what the rule describes.
+// Any hit blocks the commit with file:line ranges. jgrep is optional by
+// construction: it is called through PATH, never bundled; when it is not
+// installed (or fails) the gate allows and logs why, so a harness without
+// jgrep behaves exactly as before.
+export const semanticDiffGate = {
+    id: "semantic-diff-gate",
+    name: "Semantic Diff Gate",
+    description: "Before git commit, lints the staged diff with jgrep against rule descriptions and blocks on a hit (needs jgrep on PATH)",
+    category: "quality",
+    event: "PreToolUse",
+    matcher: "Bash",
+    canBlock: true,
+    params: [
+        { name: "rules", type: "string[]", description: "English descriptions of changes that must not be committed (filled from rules with a lint: field)", required: true },
+        { name: "threshold", type: "number", description: "jgrep probability threshold for a hit", default: 0.85, required: false },
+        { name: "jgrep", type: "string", description: "jgrep command", default: "jgrep", required: false },
+    ],
+    tags: ["semantic", "jev", "jgrep", "diff", "lint", "gate"],
+    explain: {
+        allowOnce: "change the staged hunks jgrep pointed at (file:line in the reason), or unstage them",
+        change: "harness.yaml > rules: drop or edit the lint: description; threshold lives under hooks > semantic-diff-gate; uninstalling jgrep disables the gate, then omh sync",
+    },
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+[[ -z "$COMMAND" ]] && exit 0
+_omh_cmd_matches "$COMMAND" git commit || exit 0
+
+JGREP='{{{jgrep}}}'
+if ! command -v "$JGREP" >/dev/null 2>&1; then
+  _log_event "allow" "skipped: jgrep not found (npm i -g jevgrep && jgrep init to enable the semantic diff gate)"
+  exit 0
+fi
+GIT_DIR_PATH=$(git rev-parse --git-dir 2>/dev/null) || { _log_event "allow" "skipped: not a git repository"; exit 0; }
+
+# The agent usually stages and commits in one call, so at this point the index
+# does not hold what the commit will contain. Preview it in a temporary index:
+# copy the real one, replay every "git add ..." from the command (and
+# "git add -u" for commit -a/--all), then let jgrep read that index through
+# GIT_INDEX_FILE. The real index is never touched.
+TMPIDX=$(mktemp)
+if [[ -f "$GIT_DIR_PATH/index" ]]; then cp "$GIT_DIR_PATH/index" "$TMPIDX"; else rm -f "$TMPIDX"; fi
+export GIT_INDEX_FILE="$TMPIDX"
+# WIDEN=1 means the replay cannot be trusted (cd/pushd in the command, or a
+# git add that fails here): stage every change instead, so nothing that
+# the real command would stage is missed. Over-approximating can block on
+# an unrelated dirty file; missing a file would let a secret through.
+WIDEN=0
+while IFS= read -r ADD_LINE; do
+  [[ -z "$ADD_LINE" ]] && continue
+  if [[ "$ADD_LINE" == "__widen__" ]]; then WIDEN=1; continue; fi
+  IFS=$'\\t' read -r -a ADD_ARGS <<< "$ADD_LINE"
+  git "\${ADD_ARGS[@]}" >/dev/null 2>&1 || WIDEN=1
+done < <(_omh_simple_commands "$COMMAND" | awk -F '\\t' '
+  { i = 1
+    while (i <= NF && $i ~ /^[A-Za-z_][A-Za-z0-9_]*=/) i++
+    if (i > NF) next
+    if ($i == "cd" || $i == "pushd" || $i == "popd") { print "__widen__"; next }
+    if ($i != "git") next
+    i++; cdir = ""
+    while (i <= NF && $i ~ /^-/) { if ($i == "-c") i++; else if ($i == "-C") { i++; cdir = $i }; i++ }
+    if (i > NF) next
+    pre = (cdir == "" ? "" : "-C\\t" cdir "\\t")
+    if ($i == "add") {
+      line = ""
+      for (j = i + 1; j <= NF; j++) {
+        if ($j ~ /^-(p|i|e|-patch|-interactive|-edit)$/) next
+        line = line (line == "" ? "" : "\\t") $j
+      }
+      if (line != "") print pre "add\\t" line
+    } else if ($i == "commit") {
+      for (j = i + 1; j <= NF; j++) if ($j == "--all" || ($j ~ /^-[A-Za-z]+$/ && $j ~ /a/)) { print pre "add\\t-u"; break }
+    } }')
+if [[ "$WIDEN" == "1" ]]; then git add -A >/dev/null 2>&1 || true; fi
+_omh_sdg_done() { rm -f "$TMPIDX"; }
+
+RULES_RAW=$(cat <<'OMH_RULES'
+{{#each rules}}{{{this}}}
+OMH_RULES_SEP
+{{/each}}
+OMH_RULES
+)
+HITS=""
+N=0
+ERR=$(mktemp)
+while IFS= read -r RULE; do
+  [[ -z "$RULE" ]] && continue
+  N=$((N + 1))
+  STATUS=0
+  OUT=$("$JGREP" --json -t {{threshold}} --diff --staged "$RULE" 2>"$ERR") || STATUS=$?
+  case "$STATUS" in
+    0)
+      LINES=$(printf '%s' "$OUT" | jq -r '.[]? | "  \\(.file):\\(.start)-\\(.end) (p=\\(.p))"' 2>/dev/null || true)
+      [[ -n "$LINES" ]] && HITS+="rule \\"$RULE\\":
+$LINES
+" ;;
+    1) ;;
+    *)
+      _log_event "allow" "jgrep failed (exit $STATUS): $(head -c 200 "$ERR" | tr '\\n' ' ')"
+      rm -f "$ERR"; _omh_sdg_done; exit 0 ;;
+  esac
+done < <(printf '%s' "$RULES_RAW" | jq -Rs -r 'rtrimstr("\\nOMH_RULES_SEP") | split("\\nOMH_RULES_SEP\\n") | map(select(. != "")) | .[]')
+rm -f "$ERR"; _omh_sdg_done
+
+if [[ -n "$HITS" ]]; then
+  REASON="oh-my-harness: the staged diff matches a lint rule; fix these hunks before committing:
+$HITS"
+  _log_event "block" "$REASON"
+  _emit_decision "block" "$REASON"
+  exit 0
+fi
+_log_event "allow" "no lint hits ($N rules)"
+exit 0`,
+};

package/dist/catalog/blocks/semantic-rule-guard.d.ts

@@ -0,0 +1,2 @@
+import type { BuildingBlock } from "../types.js";
+export declare const semanticRuleGuard: BuildingBlock;

package/dist/catalog/blocks/semantic-rule-guard.js

@@ -0,0 +1,95 @@
+// Rules become enforceable (#144). For every Bash / Edit / Write call, ask
+// Jev one yes/no question per enforced rule ("does this tool call violate
+// the rule?") in a single fan-out request and act on the calibrated
+// probability: block at or above blockAbove, ask in the middle band (on
+// runtimes with ask; elsewhere allow and log a warning), allow below.
+// This layer is additive: no key, no curl, an API error or a timeout all
+// mean "allow and log skipped". It never relaxes a deterministic guard.
+// State sent to Jev is the tool input only (command, path, truncated text).
+export const semanticRuleGuard = {
+    id: "semantic-rule-guard",
+    name: "Semantic Rule Guard",
+    description: "Judges every Bash/Edit/Write call against your enforced rules with Jev and blocks clear violations",
+    category: "security",
+    event: "PreToolUse",
+    matcher: "Bash|Edit|Write|MultiEdit",
+    canBlock: true,
+    params: [
+        { name: "rules", type: "string[]", description: "Rule statements to enforce (filled from rules marked enforce: true)", required: true },
+        { name: "blockAbove", type: "number", description: "Block when the violation probability is at or above this", default: 0.9, required: false },
+        { name: "askAbove", type: "number", description: "Ask for confirmation when the probability is at or above this (below blockAbove)", default: 0.6, required: false },
+    ],
+    tags: ["semantic", "jev", "rules", "guard"],
+    explain: {
+        allowOnce: "rewrite the call so it clearly does not do what the rule forbids, or answer the ask prompt",
+        change: "harness.yaml > rules: remove enforce: true from the rule, or edit its text; thresholds live under hooks > semantic-rule-guard (blockAbove / askAbove), then omh sync",
+    },
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+case "$TOOL" in Bash|Edit|Write|MultiEdit) ;; *) exit 0 ;; esac
+
+KEY="\${TYPESAFE_API_KEY:-}"
+if [[ -z "$KEY" && -f "$_OMH_PROJECT_ROOT/.env" ]]; then
+  KEY=$(sed -nE 's/^[[:space:]]*(export[[:space:]]+)?TYPESAFE_API_KEY[[:space:]]*=[[:space:]]*"?([^"#[:space:]]+)"?.*/\\2/p' "$_OMH_PROJECT_ROOT/.env" | head -n 1)
+fi
+if [[ -z "$KEY" ]]; then _log_event "allow" "skipped: no TYPESAFE_API_KEY"; exit 0; fi
+command -v curl >/dev/null 2>&1 || { _log_event "allow" "skipped: curl not found"; exit 0; }
+
+# Rules arrive through a quoted heredoc so any characters survive; one rule per separator.
+RULES_RAW=$(cat <<'OMH_RULES'
+{{#each rules}}{{{this}}}
+OMH_RULES_SEP
+{{/each}}
+OMH_RULES
+)
+RULES_JSON=$(printf '%s' "$RULES_RAW" | jq -Rs 'rtrimstr("\\nOMH_RULES_SEP") | split("\\nOMH_RULES_SEP\\n") | map(select(. != ""))')
+[[ "$(echo "$RULES_JSON" | jq 'length')" -gt 0 ]] || exit 0
+
+STATE=$(echo "$INPUT" | jq -c '{
+  tool: .tool_name,
+  command: .tool_input.command,
+  description: .tool_input.description,
+  file_path: .tool_input.file_path,
+  old_string: ((.tool_input.old_string // "") | .[0:2000]),
+  new_string: ((.tool_input.new_string // "") | .[0:4000]),
+  content: ((.tool_input.content // "") | .[0:4000])
+} | with_entries(select(.value != null and .value != ""))')
+BODY=$(jq -cn --argjson state "$STATE" --argjson rules "$RULES_JSON" '{
+  model: "jev-latest", state: $state,
+  questions: ($rules | to_entries | map({
+    key: ("rule:" + ((.key + 1) | tostring)),
+    value: {type: "noul", instructions: ("Does this tool call violate the following project rule? Rule: " + .value + " Answer yes only if the call clearly does what the rule forbids.")}
+  }) | from_entries)}')
+
+RESP=$(curl -sS -m 10 -X POST "\${OMH_TYPESAFE_ENDPOINT:-https://api.typesafe.ai/v1/systemone}" \\
+  -H "Authorization: Bearer $KEY" -H "Content-Type: application/json" --data-binary "$BODY" -w '\\n%{http_code}' 2>/dev/null) || RESP=$'\\n000'
+CODE="\${RESP##*$'\\n'}"; RESP="\${RESP%$'\\n'*}"
+if [[ "$CODE" != "200" ]]; then _log_event "allow" "skipped: TypeSafe API $CODE"; exit 0; fi
+
+TOP=$(echo "$RESP" | jq -r '[.answers // {} | to_entries[] | select(.value.type == "noul") | {i: (.key | ltrimstr("rule:") | tonumber), p: .value.noul}] | max_by(.p) // empty | "\\(.i) \\(.p)"')
+[[ -z "$TOP" ]] && { _log_event "allow" "skipped: no answers"; exit 0; }
+IDX="\${TOP%% *}"; P="\${TOP#* }"
+RULE=$(echo "$RULES_JSON" | jq -r --argjson i "$IDX" '.[$i - 1]')
+PSHORT=$(printf '%.2f' "$P")
+BLOCK_AT={{blockAbove}}
+ASK_AT={{askAbove}}
+if awk -v p="$P" -v t="$BLOCK_AT" 'BEGIN { exit !(p >= t) }'; then
+  REASON="oh-my-harness: this call violates an enforced rule (p=$PSHORT): $RULE"
+  _log_event "block" "$REASON"
+  _emit_decision "block" "$REASON"
+  exit 0
+fi
+if awk -v p="$P" -v t="$ASK_AT" 'BEGIN { exit !(p >= t) }'; then
+  REASON="oh-my-harness: this call may violate an enforced rule (p=$PSHORT): $RULE"
+  if printf '%s' "$INPUT" | jq -e 'has("transcript_path")' >/dev/null 2>&1; then
+    _log_event "allow" "ask: $REASON"
+    jq -cn --arg reason "$REASON" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"ask",permissionDecisionReason:$reason}}'
+  else
+    _log_event "allow" "warn: $REASON"
+  fi
+  exit 0
+fi
+exit 0`,
+};

package/dist/cli/commands/doctor.js

@@ -5,6 +5,7 @@ import { OMH_HOOKS_DIR } from "../../utils/paths.js";
 import { computeDrift, HarnessNotFoundError } from "../../core/drift.js";
 import { loadProviderConfig } from "../../nl/config-store.js";
 import { resolveTypesafeApiKey } from "../../nl/typesafe-chooser.js";
+import { commandExists } from "../deps-checker.js";
 export async function doctorCommand(options = {}) {
     const projectDir = options.projectDir ?? process.cwd();
     const messages = [];
@@ -185,6 +186,9 @@ async function checkProviderConfig(messages, projectDir) {
     const jev = Boolean(resolveTypesafeApiKey(projectDir));
     if (jev) {
         messages.push("INFO: Chooser: TypeSafe Jev (TYPESAFE_API_KEY found) — `omh init \"...\"` picks catalog blocks with it; no LLM provider needed.");
+        if (!(await commandExists("jgrep"))) {
+            messages.push("INFO: jgrep not found — `npm i -g jevgrep && jgrep init` enables semantic-diff-gate (strict preset, rules with lint:).");
+        }
     }
     const config = await loadProviderConfig();
     if (!config) {

package/dist/cli/commands/init.js

@@ -5,6 +5,7 @@ import { generate } from "../../core/generator.js";
 import { generateHarnessConfig, providerConfigFromEnv } from "../../nl/parse-intent.js";
 import { hasProviderConfig } from "../../nl/config-store.js";
 import { buildPresetHarness, isPresetName, PRESET_NAMES } from "../../core/presets.js";
+import { commandExists } from "../deps-checker.js";
 import { chooseWithJev, harnessFromChoices, resolveTypesafeApiKey, TYPESAFE_MODEL } from "../../nl/typesafe-chooser.js";
 import { detectProject } from "../../detector/project-detector.js";
 import { harnessToMergedConfigV2 } from "../../core/harness-converter-v2.js";
@@ -93,9 +94,10 @@ export async function initWithNL(projectDir, options) {
     const typesafeKey = resolveTypesafeApiKey(projectDir);
     const registryBlocks = registry.list();
     let harness;
+    const jgrep = await commandExists("jgrep");
     if (preset) {
-        harness = buildPresetHarness(preset, facts, { description: description || undefined });
-        console.log(`preset: ${preset}`);
+        harness = buildPresetHarness(preset, facts, { description: description || undefined }, { jgrep });
+        console.log(`preset: ${preset}${preset === "strict" ? (jgrep ? " (jgrep found: semantic-diff-gate enabled)" : " (install jgrep to add the semantic diff gate: npm i -g jevgrep)") : ""}`);
     }
     else if (options.nlRunner) {
         harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks, facts);
@@ -103,7 +105,7 @@ export async function initWithNL(projectDir, options) {
     else if (typesafeKey && description) {
         try {
             const result = await chooseWithJev({ description, facts, blocks: registryBlocks }, { apiKey: typesafeKey });
-            const applied = harnessFromChoices(result, facts, { description });
+            const applied = harnessFromChoices(result, facts, { description }, { jgrep });
             const on = [...result.blocks].filter(([, v]) => v === "on").map(([k]) => k);
             const off = [...result.blocks].filter(([, v]) => v === "off").map(([k]) => k);
             const undecided = [...result.blocks].filter(([, v]) => v === "undecided").map(([k]) => k);

package/dist/cli/commands/test.js

@@ -15,6 +15,8 @@ export function formatCategoryName(category) {
         "harness-guard": "Harness self-protection",
         "no-verify-guard": "Git hook bypass guard",
         "stop-test-gate": "Stop test gate",
+        "semantic-rule-guard": "Semantic rule guard (Jev)",
+        "semantic-diff-gate": "Semantic diff gate (jgrep)",
         "force-push-guard": "Force push guard",
         "branch-guard": "Branch guard",
         "lockfile-guard": "Lockfile guard",

package/dist/cli/deps-checker.d.ts

@@ -7,4 +7,5 @@ export interface DepCheck {
     installed: boolean;
     version?: string;
 }
+export declare function commandExists(command: string): Promise<boolean>;
 export declare function checkDependencies(): Promise<DepCheck[]>;

package/dist/cli/deps-checker.js

@@ -35,7 +35,7 @@ const DEPS = [
         installHint: "brew install node",
     },
 ];
-async function commandExists(command) {
+export async function commandExists(command) {
     try {
         await execFileAsync("which", [command]);
         return true;

package/dist/cli/harness-tester.js

@@ -12,6 +12,7 @@ export async function simulateHook(hookPath, input, cwd) {
         }, 5000);
         const child = spawn("bash", [hookPath], {
             cwd,
+            env: { ...process.env, OMH_DRY_RUN: "1" },
             stdio: ["pipe", "pipe", "pipe"],
         });
         let stdout = "";
@@ -72,7 +73,8 @@ export async function getRegisteredHooks(projectDir) {
 }
 // 테스트 실행
 export async function runTestCase(projectDir, testCase) {
-    const hookPath = path.join(projectDir, testCase.hookScript);
+    // settings.json registers hooks as `bash '/abs/path.sh'`, so hookScript is usually absolute
+    const hookPath = path.isAbsolute(testCase.hookScript) ? testCase.hookScript : path.join(projectDir, testCase.hookScript);
     try {
         await fs.access(hookPath);
     }

package/dist/cli/tui/init-flow.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import fs from "node:fs/promises";
 import path from "node:path";
 import yaml from "js-yaml";
-import { checkDependencies } from "../deps-checker.js";
+import { checkDependencies, commandExists } from "../deps-checker.js";
 import { checkReferencedTools } from "../tool-checker.js";
 import { writeHarnessState } from "../commands/init.js";
 import { generate } from "../../core/generator.js";
@@ -161,7 +161,7 @@ export async function runInitTUI(options) {
             ],
         });
         handleCancel(preset);
-        harnessConfig = buildPresetHarness(preset, projectFacts);
+        harnessConfig = buildPresetHarness(preset, projectFacts, {}, { jgrep: await commandExists("jgrep") });
         p.note(formatConfigSummary(harnessConfig), `Preset: ${preset}`);
         const confirmed = await p.confirm({ message: "Proceed with this configuration?", initialValue: true });
         handleCancel(confirmed);
@@ -193,7 +193,7 @@ export async function runInitTUI(options) {
             const catalogRegistry = await createDefaultRegistry();
             if (jevKey) {
                 const result = await chooseWithJev({ description: description, facts: projectFacts, blocks: catalogRegistry.list() }, { apiKey: jevKey });
-                const applied = harnessFromChoices(result, projectFacts, { description: description });
+                const applied = harnessFromChoices(result, projectFacts, { description: description }, { jgrep: await commandExists("jgrep") });
                 const { skipped, ...rest } = applied;
                 harnessConfig = rest;
                 genSpinner.stop(`Jev chose strictness=${result.strictness} (${result.usage?.input_tokens ?? "?"} input tokens)`);

package/dist/core/harness-converter-v2.d.ts

@@ -3,12 +3,6 @@ import type { MergedConfig } from "./merged-config.js";
 import type { CatalogRegistry } from "../catalog/registry.js";
 import type { HookEntry } from "../catalog/types.js";
 export declare const ALWAYS_ON_GUARDS: readonly ["harness-guard", "no-verify-guard", "force-push-guard"];
-/**
- * The hook entries a harness really runs: enforcement-derived + explicit +
- * loop-guard (when the loop is on) + the always-on guards, in the order the
- * generator emits them. `omh test` and `omh stats` use this so they see the
- * same set (QA: they used to miss the always-on guards).
- */
 export declare function effectiveHookEntries(harness: HarnessConfig, registry: {
     has(id: string): boolean;
 }): HookEntry[];

package/dist/core/harness-converter-v2.js

@@ -91,9 +91,30 @@ function addLoopGuard(entries, harness) {
  * generator emits them. `omh test` and `omh stats` use this so they see the
  * same set (QA: they used to miss the always-on guards).
  */
+// Rules can carry their own enforcement (#144, #145): `enforce: true` sends
+// the rule to semantic-rule-guard on every tool call; `lint:` sends a change
+// description to semantic-diff-gate before commits. The blocks are added only
+// when such rules exist; an explicit entry keeps its own params and mode.
+function addRuleDerivedGuards(entries, harness, registry) {
+    const enforced = harness.rules.filter((r) => r.enforce).map((r) => `${r.title}: ${r.content}`);
+    const lints = harness.rules.map((r) => r.lint).filter((l) => Boolean(l && l.trim()));
+    for (const [block, rules] of [["semantic-rule-guard", enforced], ["semantic-diff-gate", lints]]) {
+        if (rules.length === 0 || !registry.has(block))
+            continue;
+        const explicit = entries.find((h) => h.block === block);
+        if (!explicit) {
+            entries.push({ block, params: { rules: [...rules] }, mode: "block" });
+            continue;
+        }
+        // An explicit entry (the strict preset writes one) keeps its params and mode; rule-derived texts are appended.
+        const own = Array.isArray(explicit.params.rules) ? explicit.params.rules : [];
+        explicit.params = { ...explicit.params, rules: [...own, ...rules.filter((r) => !own.includes(r))] };
+    }
+}
 export function effectiveHookEntries(harness, registry) {
     const entries = mergeEnforcementAndHooks(harness);
     addLoopGuard(entries, harness);
+    addRuleDerivedGuards(entries, harness, registry);
     addAlwaysOnGuards(entries, registry);
     return entries;
 }
@@ -125,6 +146,7 @@ export async function harnessToMergedConfigV2(harness, registry, projectDir) {
     }
     // Resolve registry — use provided one or create the default
     const resolvedRegistry = registry ?? (await createDefaultRegistry());
+    addRuleDerivedGuards(allHookEntries, harness, resolvedRegistry);
     addAlwaysOnGuards(allHookEntries, resolvedRegistry);
     const catalogResult = await convertHookEntries(allHookEntries, resolvedRegistry, projectDir ?? ".");
     // Convert hooksConfig entries from catalog into HookDefinition format.

package/dist/core/harness-schema.d.ts

@@ -59,16 +59,24 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         title: z.ZodString;
         content: z.ZodString;
         priority: z.ZodDefault<z.ZodNumber>;
+        /** Judge every Bash/Edit/Write call against this rule with Jev (semantic-rule-guard, #144). */
+        enforce: z.ZodOptional<z.ZodBoolean>;
+        /** English description of a change that must not be committed; checked on the staged diff with jgrep (semantic-diff-gate, #145). */
+        lint: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         id: string;
         content: string;
         title: string;
         priority: number;
+        enforce?: boolean | undefined;
+        lint?: string | undefined;
     }, {
         id: string;
         content: string;
         title: string;
         priority?: number | undefined;
+        enforce?: boolean | undefined;
+        lint?: string | undefined;
     }>, "many">>;
     enforcement: z.ZodDefault<z.ZodObject<{
         preCommit: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
@@ -248,6 +256,8 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         content: string;
         title: string;
         priority: number;
+        enforce?: boolean | undefined;
+        lint?: string | undefined;
     }[];
     enforcement: {
         blockedPaths: string[];
@@ -313,6 +323,8 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         content: string;
         title: string;
         priority?: number | undefined;
+        enforce?: boolean | undefined;
+        lint?: string | undefined;
     }[] | undefined;
     enforcement?: {
         blockedPaths?: string[] | undefined;

package/dist/core/harness-schema.js

@@ -40,6 +40,10 @@ export const HarnessConfigSchema = z.object({
         title: z.string(),
         content: z.string(),
         priority: z.number().default(50),
+        /** Judge every Bash/Edit/Write call against this rule with Jev (semantic-rule-guard, #144). */
+        enforce: z.boolean().optional(),
+        /** English description of a change that must not be committed; checked on the staged diff with jgrep (semantic-diff-gate, #145). */
+        lint: z.string().optional(),
     })).default([]),
     // Enforcement hooks
     enforcement: z.object({

package/dist/core/presets.d.ts

@@ -10,8 +10,12 @@ type Params = Record<string, unknown>;
  * catalog defaults are enough.
  */
 export declare function defaultParamsFor(blockId: string, facts?: ProjectFacts): Params | null;
+/** Generic change descriptions the strict preset lints with jgrep when it is installed (#145). */
+export declare const STRICT_LINTS: string[];
 export declare function buildPresetHarness(preset: PresetName, facts?: ProjectFacts, meta?: {
     name?: string;
     description?: string;
+}, tools?: {
+    jgrep?: boolean;
 }): HarnessConfig;
 export {};

package/dist/core/presets.js

@@ -98,7 +98,13 @@ const RULES = {
         ].join("\n"),
     },
 };
-export function buildPresetHarness(preset, facts, meta = {}) {
+/** Generic change descriptions the strict preset lints with jgrep when it is installed (#145). */
+export const STRICT_LINTS = [
+    "catches an error and silently ignores it",
+    "hardcodes a secret, token or password",
+    "disables or skips a test instead of fixing it",
+];
+export function buildPresetHarness(preset, facts, meta = {}, tools = {}) {
     const hooks = [];
     for (const block of HOOKS_BY_PRESET[preset]) {
         const params = defaultParamsFor(block, facts);
@@ -106,6 +112,9 @@ export function buildPresetHarness(preset, facts, meta = {}) {
             continue;
         hooks.push({ block, params, mode: "block" });
     }
+    if (preset === "strict" && tools.jgrep) {
+        hooks.push({ block: "semantic-diff-gate", params: { rules: [...STRICT_LINTS] }, mode: "block" });
+    }
     const stacks = (facts?.languages ?? []).map((language, i) => ({
         name: language,
         framework: facts?.frameworks?.[i] ?? facts?.frameworks?.[0] ?? "none",

package/dist/generators/hooks.js

@@ -315,6 +315,8 @@ _OMH_EVENT="${event}"
 _OMH_DECISION_MODE="${mode}"
 _OMH_LOGGED=0
 _log_event() {
+  # omh test runs hooks as dry runs: decisions are reported, never recorded.
+  if [ -n "\${OMH_DRY_RUN:-}" ]; then _OMH_LOGGED=1; return 0; fi
   # Build the JSONL record entirely through jq so every string field is
   # JSON-escaped (quotes, backslashes, newlines, unicode). The previous
   # printf+%s approach corrupted the line whenever reason or any other

package/dist/nl/typesafe-chooser.d.ts

@@ -64,6 +64,8 @@ export declare function applyChoices(base: HarnessConfig, result: Pick<ChooserRe
 /** Preset to start from, then the chooser's decisions on top. */
 export declare function harnessFromChoices(result: Pick<ChooserResult, "strictness" | "blocks">, facts: ProjectFacts | undefined, meta: {
     description?: string;
+}, tools?: {
+    jgrep?: boolean;
 }): AppliedHarness;
 /** TYPESAFE_API_KEY from the environment, else from a .env file in the project directory. */
 export declare function resolveTypesafeApiKey(projectDir: string, env?: NodeJS.ProcessEnv): string | undefined;

package/dist/nl/typesafe-chooser.js

@@ -110,8 +110,8 @@ export function applyChoices(base, result, facts) {
     return { ...base, hooks, skipped };
 }
 /** Preset to start from, then the chooser's decisions on top. */
-export function harnessFromChoices(result, facts, meta) {
-    const base = buildPresetHarness(result.strictness, facts, meta);
+export function harnessFromChoices(result, facts, meta, tools = {}) {
+    const base = buildPresetHarness(result.strictness, facts, meta, tools);
     return applyChoices(base, result, facts);
 }
 /** TYPESAFE_API_KEY from the environment, else from a .env file in the project directory. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-harness",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Tame your AI coding agents with natural language",
   "type": "module",
   "bin": {