oh-my-harness 0.23.0 → 0.24.0

package/README.md

@@ -99,6 +99,7 @@ omh init "Next.js + FastAPI, TDD enforced, no auto PRs"
 - Get a key from the [TypeSafe console](https://typesafe.ai) (early access at the time of writing). One init costs a fraction of a cent (input $0.042 per million tokens, output free) and takes about half a second.
 - `--preset` always wins and never calls Jev. No key and no LLM provider? `omh init "description"` falls back to `safe` and says so.
 - `omh doctor` and `omh config --show` tell you whether the chooser is active. Remove the key to go back to the LLM providers or presets.
+- `omh modify "..."` later edits the same way: Jev answers enable / disable / ask / keep per block, you confirm the change set, `omh sync` runs. Mark an entry `locked: true` in harness.yaml and modify will refuse to remove or weaken it.
 - Interactive `omh init` offers both: "Describe your project (Jev picks the blocks)" and "Use a preset (no AI)".
 - Descriptions in English work best; other languages are handled but with lower confidence, so include the specifics.
 
@@ -119,6 +120,8 @@ All enforcement is powered by **catalog blocks** — reusable, parameterized hoo
 | 🪝 `harness-guard` | security | Blocks shell writes to the harness's own hooks and config (always on) |
 | 🚫 `no-verify-guard` | git | Blocks `--no-verify` / `-n` / hooksPath overrides on commit and push (always on) |
 | 💥 `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 |
 | 📁 `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 |
@@ -192,6 +195,7 @@ Hand omh a `WORKPLAN.md` and it runs one work order per fresh agent session, in
 omh init "your project description"      # Jev with TYPESAFE_API_KEY, else an LLM provider, else the "safe" preset
 omh init --preset strict                  # No provider: minimal | safe | strict
 omh explain                               # Why were the last tool calls blocked, and what to do about it
+omh modify "no auto PRs, TDD guard asks"  # Edit harness.yaml from a sentence (Jev decides per block; locked: true entries stay)
 omh init                                  # Interactive TUI (import existing harness.yaml)
 
 # 📋 Catalog

package/dist/catalog/blocks/commit-test-gate.js

@@ -27,7 +27,11 @@ INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 if _omh_cmd_matches "$COMMAND" git commit; then
   FP=$(_omh_tree_fingerprint)
-  if _omh_gate_cached commit-test-gate {{cacheTtlSeconds}} "$FP"; then
+  GATE_CMD=$(cat <<'OMH_GATE_CMD'
+{{{testCommand}}}
+OMH_GATE_CMD
+)
+  if _omh_gate_cached commit-test-gate {{cacheTtlSeconds}} "$FP" "$GATE_CMD"; then
     echo "oh-my-harness: tests already passed on this exact tree; skipping" >&2
     _log_event "allow" "cached: tree unchanged since last passing run"
     exit 0
@@ -39,7 +43,7 @@ if _omh_cmd_matches "$COMMAND" git commit; then
     _emit_decision "block" "$REASON"
     exit 0
   fi
-  _omh_gate_record commit-test-gate "$FP"
+  _omh_gate_record commit-test-gate "$FP" "$GATE_CMD"
 fi
 exit 0`,
 };

package/dist/catalog/blocks/commit-typecheck-gate.js

@@ -27,7 +27,11 @@ INPUT=$(cat)
 COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 if _omh_cmd_matches "$COMMAND" git commit; then
   FP=$(_omh_tree_fingerprint)
-  if _omh_gate_cached commit-typecheck-gate {{cacheTtlSeconds}} "$FP"; then
+  GATE_CMD=$(cat <<'OMH_GATE_CMD'
+{{{typecheckCommand}}}
+OMH_GATE_CMD
+)
+  if _omh_gate_cached commit-typecheck-gate {{cacheTtlSeconds}} "$FP" "$GATE_CMD"; then
     echo "oh-my-harness: typecheck already passed on this exact tree; skipping" >&2
     _log_event "allow" "cached: tree unchanged since last passing run"
     exit 0
@@ -39,7 +43,7 @@ if _omh_cmd_matches "$COMMAND" git commit; then
     _emit_decision "block" "$REASON"
     exit 0
   fi
-  _omh_gate_record commit-typecheck-gate "$FP"
+  _omh_gate_record commit-typecheck-gate "$FP" "$GATE_CMD"
 fi
 exit 0`,
 };

package/dist/catalog/blocks/index.js

@@ -19,6 +19,8 @@ import { loopGuard } from "./loop-guard.js";
 import { harnessGuard } from "./harness-guard.js";
 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";
 export const builtinBlocks = [
     branchGuard,
     commitTestGate,
@@ -41,4 +43,6 @@ export const builtinBlocks = [
     harnessGuard,
     noVerifyGuard,
     forcePushGuard,
+    stopTestGate,
+    stopUncommittedWarn,
 ];

package/dist/catalog/blocks/stop-test-gate.d.ts

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

package/dist/catalog/blocks/stop-test-gate.js

@@ -0,0 +1,81 @@
+// Stop-event gate (#117): when the agent is about to end its turn with a red
+// test suite, hand the failure back so it keeps working instead of finishing
+// on a broken tree. Two safety valves: Claude's stop_hook_active flag (a Stop
+// hook that blocked once must not block the follow-up stop) and a per-session
+// retry cap kept in .omh/state, which also covers runtimes without that flag.
+// The tree-fingerprint cache shared with commit-test-gate means a suite that
+// just passed on this exact tree is not run again.
+export const stopTestGate = {
+    id: "stop-test-gate",
+    name: "Stop Test Gate",
+    description: "Runs tests when the agent tries to end its turn and sends it back to work while they fail",
+    category: "quality",
+    event: "Stop",
+    canBlock: true,
+    params: [
+        { name: "testCommand", type: "string", description: "Test command to run before the turn may end", required: true },
+        {
+            name: "maxRetries",
+            type: "number",
+            description: "How many times per session the turn may be sent back before the gate gives up and lets it end",
+            default: 2,
+            required: false,
+        },
+        {
+            name: "cacheTtlSeconds",
+            type: "number",
+            description: "Skip the run when the working tree is unchanged since the last pass and that pass is younger than this many seconds (0 disables)",
+            default: 600,
+            required: false,
+        },
+    ],
+    tags: ["stop", "test", "quality", "gate"],
+    explain: {
+        allowOnce: "make the test command pass; after maxRetries send-backs in one session the gate lets the turn end anyway",
+        change: "harness.yaml > hooks > stop-test-gate: change testCommand, maxRetries or cacheTtlSeconds, or remove it, then omh sync",
+    },
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+# A Stop hook that already sent the agent back must not block the follow-up stop.
+[[ "$(echo "$INPUT" | jq -r '.stop_hook_active // false' 2>/dev/null)" == "true" ]] && exit 0
+
+SESSION=$(echo "$INPUT" | jq -r '.session_id // "default"' 2>/dev/null | tr -c 'A-Za-z0-9_-' '_')
+STATE_DIR="\${_OMH_STATE_DIR:-.omh/state}"
+COUNT_FILE="$STATE_DIR/stop-test-gate-\${SESSION}.count"
+COUNT=$(cat "$COUNT_FILE" 2>/dev/null || echo 0)
+[[ "$COUNT" =~ ^[0-9]+$ ]] || COUNT=0
+if [[ "$COUNT" -ge {{maxRetries}} ]]; then
+  _log_event "allow" "stop-test-gate: retry cap ({{maxRetries}}) reached for this session; letting the turn end"
+  exit 0
+fi
+
+FP=$(_omh_tree_fingerprint)
+GATE_CMD=$(cat <<'OMH_GATE_CMD'
+{{{testCommand}}}
+OMH_GATE_CMD
+)
+if _omh_gate_cached stop-test-gate {{cacheTtlSeconds}} "$FP" "$GATE_CMD"; then
+  rm -f "$COUNT_FILE"
+  _log_event "allow" "cached: tree unchanged since last passing run"
+  exit 0
+fi
+
+STATUS=0
+set -o pipefail
+ESC=$'\\x1b'
+OUTPUT=$(NO_COLOR=1 FORCE_COLOR=0 {{{testCommand}}} 2>&1 | sed "s/\${ESC}\\[[0-9;]*[A-Za-z]//g") || STATUS=$?
+if [[ "$STATUS" -ne 0 ]]; then
+  mkdir -p "$STATE_DIR" 2>/dev/null || true
+  echo $((COUNT + 1)) > "$COUNT_FILE"
+  TAIL=$(printf '%s\\n' "$OUTPUT" | tail -n 15)
+  REASON="oh-my-harness: the test suite is failing; fix it before ending the turn (attempt $((COUNT + 1))/{{maxRetries}}):
+$TAIL"
+  _log_event "block" "$REASON"
+  jq -cn --arg r "$REASON" '{decision:"block", reason:$r, hookSpecificOutput:{hookEventName:"Stop", decision:"block", reason:$r}}'
+  exit 0
+fi
+rm -f "$COUNT_FILE"
+_omh_gate_record stop-test-gate "$FP" "$GATE_CMD"
+exit 0`,
+};

package/dist/catalog/blocks/stop-uncommitted-warn.d.ts

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

package/dist/catalog/blocks/stop-uncommitted-warn.js

@@ -0,0 +1,30 @@
+// Stop-event notice (#117): when the turn ends with uncommitted changes, say
+// so as a system message. Never blocks; the point is that the human sees what
+// was left behind instead of discovering it later.
+export const stopUncommittedWarn = {
+    id: "stop-uncommitted-warn",
+    name: "Stop Uncommitted Warning",
+    description: "When the agent ends its turn with uncommitted changes, lists them as a system message (never blocks)",
+    category: "git",
+    event: "Stop",
+    canBlock: false,
+    params: [],
+    tags: ["stop", "git", "notice"],
+    template: `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
+if ! CHANGES=$(git status --porcelain 2>&1); then
+  MSG="oh-my-harness: could not read git status, so uncommitted changes may be unreported: $(printf '%s' "$CHANGES" | head -n 3)"
+  _log_event "allow" "$MSG"
+  jq -cn --arg m "$MSG" '{systemMessage:$m}'
+  exit 0
+fi
+[[ -z "$CHANGES" ]] && exit 0
+N=$(printf '%s\\n' "$CHANGES" | wc -l | tr -d ' ')
+MSG="oh-my-harness: $N uncommitted change(s) left behind:
+$(printf '%s\\n' "$CHANGES" | head -n 20)"
+_log_event "allow" "$MSG"
+jq -cn --arg m "$MSG" '{systemMessage:$m}'
+exit 0`,
+};

package/dist/catalog/types.d.ts

@@ -31,6 +31,8 @@ export interface HookEntry {
     block: string;
     params: Record<string, unknown>;
     mode?: "block" | "ask";
+    /** `omh modify` may never remove or weaken a locked entry (#118). */
+    locked?: boolean;
 }
 export declare const ParamDefinitionSchema: z.ZodObject<{
     name: z.ZodString;
@@ -82,7 +84,7 @@ export declare const BuildingBlockSchema: z.ZodObject<{
     tags: z.ZodArray<z.ZodString, "many">;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "UserPromptSubmit" | "Stop" | "PreCompact" | "PostCompact" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "WorktreeRemove";
+    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "Stop" | "SubagentStop" | "UserPromptSubmit" | "PreCompact" | "PostCompact" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "WorktreeRemove";
     name: string;
     params: {
         name: string;
@@ -99,7 +101,7 @@ export declare const BuildingBlockSchema: z.ZodObject<{
     matcher?: string | undefined;
 }, {
     id: string;
-    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "UserPromptSubmit" | "Stop" | "PreCompact" | "PostCompact" | "SubagentStop" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "WorktreeRemove";
+    event: "PreToolUse" | "PostToolUse" | "SessionStart" | "Notification" | "ConfigChange" | "WorktreeCreate" | "Stop" | "SubagentStop" | "UserPromptSubmit" | "PreCompact" | "PostCompact" | "PreBash" | "PostBash" | "PreEdit" | "PostEdit" | "PreRead" | "PostRead" | "PreWrite" | "PostWrite" | "SessionEnd" | "PreToolResult" | "PostToolResult" | "WorktreeRemove";
     name: string;
     params: {
         name: string;
@@ -119,12 +121,16 @@ export declare const HookEntrySchema: z.ZodObject<{
     block: z.ZodString;
     params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     mode: z.ZodDefault<z.ZodEnum<["block", "ask"]>>;
+    /** `omh modify` may never remove or weaken a locked entry (#118). */
+    locked: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     block: string;
     params: Record<string, unknown>;
     mode: "block" | "ask";
+    locked?: boolean | undefined;
 }, {
     block: string;
     params?: Record<string, unknown> | undefined;
     mode?: "block" | "ask" | undefined;
+    locked?: boolean | undefined;
 }>;

package/dist/catalog/types.js

@@ -22,4 +22,6 @@ export const HookEntrySchema = z.object({
     block: z.string(),
     params: z.record(z.unknown()).default({}),
     mode: z.enum(["block", "ask"]).default("block"),
+    /** `omh modify` may never remove or weaken a locked entry (#118). */
+    locked: z.boolean().optional(),
 });

package/dist/cli/commands/modify.d.ts

@@ -0,0 +1,8 @@
+export interface ModifyOptions {
+    projectDir?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+}
+export declare function modifyCommand(requestParts: string[], options?: ModifyOptions): Promise<{
+    exitCode: number;
+}>;

package/dist/cli/commands/modify.js

@@ -0,0 +1,77 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import chalk from "chalk";
+import { HarnessConfigSchema } from "../../core/harness-schema.js";
+import { detectProject } from "../../detector/project-detector.js";
+import { builtinBlocks } from "../../catalog/blocks/index.js";
+import { resolveTypesafeApiKey, TYPESAFE_MODEL } from "../../nl/typesafe-chooser.js";
+import { modifyWithJev, applyModifications } from "../../nl/typesafe-modify.js";
+export async function modifyCommand(requestParts, options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    const request = requestParts.join(" ").trim();
+    if (!request) {
+        console.log('Usage: omh modify "what to change" (e.g. "no auto PRs, make the TDD guard ask instead of block")');
+        return { exitCode: 1 };
+    }
+    const apiKey = resolveTypesafeApiKey(projectDir);
+    if (!apiKey) {
+        console.log("omh modify needs TYPESAFE_API_KEY (environment or the project's .env): Jev decides which blocks the request refers to.");
+        console.log("Without it, edit harness.yaml directly and run `omh sync`.");
+        return { exitCode: 1 };
+    }
+    const harnessPath = path.join(projectDir, "harness.yaml");
+    let harness;
+    try {
+        const parsed = HarnessConfigSchema.safeParse(yaml.load(await fs.readFile(harnessPath, "utf-8")));
+        if (!parsed.success) {
+            console.log(`harness.yaml does not validate: ${parsed.error.message}`);
+            return { exitCode: 1 };
+        }
+        harness = parsed.data;
+    }
+    catch {
+        console.log("No harness.yaml here. Run `omh init` first.");
+        return { exitCode: 1 };
+    }
+    let facts;
+    try {
+        facts = await detectProject(projectDir);
+    }
+    catch { /* non-fatal */ }
+    let result;
+    try {
+        result = await modifyWithJev({ request, harness, blocks: builtinBlocks }, { apiKey });
+    }
+    catch (err) {
+        console.log(`TypeSafe chooser unavailable (${err.message}). Edit harness.yaml directly and run \`omh sync\`.`);
+        return { exitCode: 1 };
+    }
+    const applied = applyModifications(harness, result.decisions, facts, builtinBlocks);
+    console.log(chalk.dim(`Jev (${TYPESAFE_MODEL}) read the request, ${result.usage?.input_tokens ?? "?"} input tokens`));
+    for (const r of applied.refused)
+        console.log(`  ${chalk.yellow("refused")}  ${r.reason}`);
+    if (applied.changes.length === 0) {
+        console.log("No changes: Jev did not match the request to any block with enough confidence. Try naming the block or the behaviour.");
+        return { exitCode: 0 };
+    }
+    for (const c of applied.changes) {
+        const verb = c.action === "enable" ? chalk.green("enable ") : c.action === "disable" ? chalk.red("disable") : chalk.yellow("ask    ");
+        console.log(`  ${verb}  ${c.block}`);
+    }
+    if (options.dryRun) {
+        console.log(chalk.dim("dry run: harness.yaml not written"));
+        return { exitCode: 0 };
+    }
+    if (!options.yes) {
+        const { confirm } = await import("@inquirer/prompts");
+        if (!(await confirm({ message: "Apply these changes to harness.yaml and re-sync?", default: true }))) {
+            console.log("Aborted.");
+            return { exitCode: 0 };
+        }
+    }
+    await fs.writeFile(harnessPath, yaml.dump(applied.harness, { lineWidth: 120 }), "utf-8");
+    const { syncCommand } = await import("./sync.js");
+    const sync = await syncCommand({ projectDir });
+    return { exitCode: sync.exitCode };
+}

package/dist/cli/commands/test.js

@@ -14,6 +14,7 @@ export function formatCategoryName(category) {
         "command-guard": "Command guards",
         "harness-guard": "Harness self-protection",
         "no-verify-guard": "Git hook bypass guard",
+        "stop-test-gate": "Stop test gate",
         "force-push-guard": "Force push guard",
         "branch-guard": "Branch guard",
         "lockfile-guard": "Lockfile guard",

package/dist/cli/harness-tester.js

@@ -195,6 +195,16 @@ export function generateBlockTestCases(hookEntries, blocks, currentBranch, regis
                 });
                 break;
             }
+            case "stop-test-gate": {
+                cases.push({
+                    name: "Stop with stop_hook_active → ALLOWED (loop guard)",
+                    category: "stop-test-gate",
+                    hookScript,
+                    input: { tool_name: "", tool_input: {}, stop_hook_active: true, session_id: "omh-test" },
+                    expectation: "allow",
+                });
+                break;
+            }
             case "no-verify-guard": {
                 cases.push({
                     name: '"git commit --no-verify" → BLOCKED',

package/dist/cli/index.js

@@ -35,6 +35,18 @@ export function createCli() {
             process.exitCode = 1;
         }
     });
+    program
+        .command("modify [request...]")
+        .description('Edit harness.yaml from a sentence, e.g. omh modify "no auto PRs, make the TDD guard ask" (needs TYPESAFE_API_KEY)')
+        .option("-d, --project-dir <dir>", "Project directory")
+        .option("-y, --yes", "Apply without confirmation")
+        .option("--dry-run", "Show the change set without writing")
+        .action(async (request, options) => {
+        const { modifyCommand } = await import("./commands/modify.js");
+        const result = await modifyCommand(request, options);
+        if (result.exitCode !== 0)
+            process.exitCode = result.exitCode;
+    });
     program
         .command("explain")
         .description("Show the last blocked tool calls in plain language, with how to allow once and how to change the rule")

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

@@ -29,7 +29,7 @@ function harnessToMergedConfig(harness) {
         presets: ["harness"],
         variables,
         claudeMdSections,
-        hooks: { preToolUse: [], postToolUse: [], sessionStart: [], notification: [], configChange: [], worktreeCreate: [] },
+        hooks: { preToolUse: [], postToolUse: [], sessionStart: [], notification: [], configChange: [], worktreeCreate: [], stop: [] },
         settings: { permissions: { allow: harness.permissions.allow, deny: harness.permissions.deny } },
         ...(harness.loop?.enabled ? { loop: harness.loop } : {}),
     };
@@ -111,6 +111,7 @@ const eventToField = {
     Notification: "notification",
     ConfigChange: "configChange",
     WorktreeCreate: "worktreeCreate",
+    Stop: "stop",
 };
 export async function harnessToMergedConfigV2(harness, registry, projectDir) {
     // Start with base conversion (rules, variables, permissions — no inline enforcement scripts)
@@ -156,6 +157,7 @@ export async function harnessToMergedConfigV2(harness, registry, projectDir) {
         notification: [...(base.hooks.notification ?? []), ...(additionalHooks.notification ?? [])],
         configChange: [...(base.hooks.configChange ?? []), ...(additionalHooks.configChange ?? [])],
         worktreeCreate: [...(base.hooks.worktreeCreate ?? []), ...(additionalHooks.worktreeCreate ?? [])],
+        stop: [...(base.hooks.stop ?? []), ...(additionalHooks.stop ?? [])],
     };
     return {
         ...base,

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

@@ -105,14 +105,17 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         block: z.ZodString;
         params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         mode: z.ZodDefault<z.ZodEnum<["block", "ask"]>>;
+        locked: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         block: string;
         params: Record<string, unknown>;
         mode: "block" | "ask";
+        locked?: boolean | undefined;
     }, {
         block: string;
         params?: Record<string, unknown> | undefined;
         mode?: "block" | "ask" | undefined;
+        locked?: boolean | undefined;
     }>, "many">>;
     loop: z.ZodDefault<z.ZodEffects<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -205,6 +208,7 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         block: string;
         params: Record<string, unknown>;
         mode: "block" | "ask";
+        locked?: boolean | undefined;
     }[];
     permissions: {
         allow: string[];
@@ -264,6 +268,7 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         block: string;
         params?: Record<string, unknown> | undefined;
         mode?: "block" | "ask" | undefined;
+        locked?: boolean | undefined;
     }[] | undefined;
     permissions?: {
         allow?: string[] | undefined;

package/dist/core/merged-config.d.ts

@@ -21,6 +21,8 @@ export interface HooksConfig {
     notification?: HookDefinition[];
     configChange?: HookDefinition[];
     worktreeCreate?: HookDefinition[];
+    /** Stop-event hooks (#117): fire when the agent is about to end its turn. No matcher. */
+    stop?: HookDefinition[];
 }
 export interface SettingsConfig {
     permissions?: {

package/dist/core/presets.js

@@ -39,6 +39,8 @@ export function defaultParamsFor(blockId, facts) {
             return facts?.lintCommands?.[0] ? { filePattern: l.glob, command: facts.lintCommands[0] } : null;
         case "test-on-save":
             return facts?.testCommands?.[0] ? { testCommand: facts.testCommands[0], filePattern: l.src } : null;
+        case "stop-test-gate":
+            return facts?.testCommands?.[0] ? { testCommand: facts.testCommands[0] } : null;
         case "format-on-save":
             return null; // no formatter detection yet; ponytail: add when the detector learns formatters
         case "path-guard":

package/dist/generators/codex-config.js

@@ -46,7 +46,7 @@ export function buildCodexHooks(hooksOutput) {
             continue;
         }
         codexHooks.hooks[event] = entries.map((entry) => ({
-            matcher: normalizeMatcher(entry.matcher),
+            matcher: normalizeMatcher(entry.matcher ?? ""),
             hooks: entry.hooks.map((h) => ({ type: h.type, command: h.command })),
         }));
     }

package/dist/generators/hooks.d.ts

@@ -11,7 +11,7 @@ export interface HookCommand {
 }
 export interface HooksOutput {
     hooksConfig: Record<string, Array<{
-        matcher: string;
+        matcher?: string;
         hooks: HookCommand[];
     }>>;
     generatedFiles: string[];
@@ -20,7 +20,7 @@ export interface HooksPlan {
     /** Hook script files (each chmod 0o755). */
     files: PlannedFile[];
     hooksConfig: Record<string, Array<{
-        matcher: string;
+        matcher?: string;
         hooks: HookCommand[];
     }>>;
     generatedFiles: string[];

package/dist/generators/hooks.js

@@ -186,11 +186,17 @@ const OMH_TREE_FINGERPRINT = `_omh_tree_fingerprint() {
 #   _omh_gate_cached <name> <ttl-seconds> <fp>  -> 0 when the last recorded pass
 #                                                  for <name> is <fp> and younger than ttl.
 #   _omh_gate_record <name> <fp>                -> remember <fp> as passed.
+# The optional [cmd] argument becomes part of the cache key, so changing the
+# command in harness.yaml never reuses a pass recorded for the old one.
+_omh_gate_key() {
+  local name="\${1:-}" cmd="\${2:-}"
+  if [ -n "$cmd" ]; then printf '%s-%s' "$name" "$(printf '%s' "$cmd" | cksum | cut -d' ' -f1)"; else printf '%s' "$name"; fi
+}
 _omh_gate_cached() {
   local name="$1" ttl="\${2:-0}" fp="\${3:-none}" file now cached_fp cached_ts
   [ "$ttl" -gt 0 ] 2>/dev/null || return 1
   [ "$fp" = "none" ] && return 1
-  file="\${_OMH_STATE_DIR:-.omh/state}/gate-$name.fp"
+  file="\${_OMH_STATE_DIR:-.omh/state}/gate-$(_omh_gate_key "$name" "\${4:-}").fp"
   [ -f "$file" ] || return 1
   read -r cached_fp cached_ts < "$file" || return 1
   now=$(date +%s)
@@ -199,7 +205,7 @@ _omh_gate_cached() {
 _omh_gate_record() {
   local name="$1" fp="\${2:-none}" file
   [ "$fp" = "none" ] && return 0
-  file="\${_OMH_STATE_DIR:-.omh/state}/gate-$name.fp"
+  file="\${_OMH_STATE_DIR:-.omh/state}/gate-$(_omh_gate_key "$name" "\${3:-}").fp"
   mkdir -p "$(dirname "$file")" 2>/dev/null || true
   printf '%s %s\\n' "$fp" "$(date +%s)" > "$file"
 }`;
@@ -438,6 +444,7 @@ export async function computeHooks(options) {
         ["Notification", config.hooks.notification ?? []],
         ["ConfigChange", config.hooks.configChange ?? []],
         ["WorktreeCreate", config.hooks.worktreeCreate ?? []],
+        ["Stop", config.hooks.stop ?? []],
     ];
     const allHooks = eventMap.flatMap(([event, hooks]) => hooks.map((h) => ({ ...h, event })));
     // Read previous manifest to identify stale hook files to clean up.
@@ -479,7 +486,8 @@ export async function computeHooks(options) {
         if (!hooksConfig[p.event])
             hooksConfig[p.event] = [];
         hooksConfig[p.event].push({
-            matcher: p.matcher,
+            // Stop (and SubagentStop) have no matcher support in Claude Code: omit the key rather than emit "".
+            ...(p.event === "Stop" || p.event === "SubagentStop" ? {} : { matcher: p.matcher }),
             hooks: [{ type: "command", command: `bash ${shellSingleQuote(p.scriptPath)}` }],
         });
     }

package/dist/generators/pi-extension.js

@@ -36,7 +36,7 @@ export function extractPiBindings(hooksConfig) {
     const pre = hooksConfig["PreToolUse"] ?? [];
     const bindings = [];
     for (const entry of pre) {
-        const tools = matcherToPiTools(entry.matcher);
+        const tools = matcherToPiTools(entry.matcher ?? "");
         if (tools.length === 0)
             continue;
         for (const hook of entry.hooks) {

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

@@ -5,7 +5,7 @@ import { type PresetName } from "../core/presets.js";
 export declare const TYPESAFE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
 export declare const TYPESAFE_MODEL = "jev-latest";
 /** Blocks a project may or may not want. Always-on and loop-internal blocks are never asked. */
-export declare const SELECTABLE_BLOCKS: readonly ["branch-guard", "commit-test-gate", "commit-typecheck-gate", "command-guard", "path-guard", "lockfile-guard", "secret-file-guard", "tdd-guard", "sql-guard", "lint-on-save", "format-on-save", "test-on-save", "auto-pr", "desktop-notify", "compact-context"];
+export declare const SELECTABLE_BLOCKS: readonly ["branch-guard", "commit-test-gate", "commit-typecheck-gate", "command-guard", "path-guard", "lockfile-guard", "secret-file-guard", "tdd-guard", "sql-guard", "lint-on-save", "format-on-save", "test-on-save", "auto-pr", "desktop-notify", "compact-context", "stop-test-gate", "stop-uncommitted-warn"];
 export type Decision = "on" | "off" | "undecided";
 export interface ChooserInput {
     description: string;

package/dist/nl/typesafe-chooser.js

@@ -16,6 +16,7 @@ export const SELECTABLE_BLOCKS = [
     "branch-guard", "commit-test-gate", "commit-typecheck-gate", "command-guard", "path-guard",
     "lockfile-guard", "secret-file-guard", "tdd-guard", "sql-guard",
     "lint-on-save", "format-on-save", "test-on-save", "auto-pr", "desktop-notify", "compact-context",
+    "stop-test-gate", "stop-uncommitted-warn",
 ];
 export const THRESHOLDS = { on: 0.65, off: 0.35, choiceConfidence: 0.5 };
 export function buildJevRequest(input) {

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

@@ -0,0 +1,51 @@
+import type { HarnessConfig } from "../core/harness-schema.js";
+import type { BuildingBlock } from "../catalog/types.js";
+import type { ProjectFacts } from "../detector/types.js";
+export declare const MODIFY_ACTIONS: readonly ["enable", "disable", "ask", "keep"];
+export type ModifyAction = (typeof MODIFY_ACTIONS)[number];
+export interface ModifyInput {
+    request: string;
+    harness: HarnessConfig;
+    blocks: Pick<BuildingBlock, "id" | "description">[];
+}
+export interface ModifyRequest {
+    model: string;
+    state: Record<string, unknown>;
+    questions: Record<string, Record<string, unknown>>;
+}
+type ChoiceAnswer = {
+    type: "choice";
+    choice: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+};
+export declare function buildModifyRequest(input: ModifyInput): ModifyRequest;
+export declare function routeModifyAnswers(answers: Record<string, ChoiceAnswer | {
+    type: string;
+}>): Map<string, ModifyAction>;
+export interface ModifyResult {
+    decisions: Map<string, ModifyAction>;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export declare function modifyWithJev(input: ModifyInput, opts: {
+    apiKey: string;
+    timeoutMs?: number;
+}): Promise<ModifyResult>;
+export interface AppliedModifications {
+    harness: HarnessConfig;
+    changes: {
+        block: string;
+        action: ModifyAction;
+    }[];
+    refused: {
+        block: string;
+        action: ModifyAction;
+        reason: string;
+    }[];
+}
+/** Apply decisions as structured edits. `locked: true` entries are never removed or weakened. */
+export declare function applyModifications(harness: HarnessConfig, decisions: Map<string, ModifyAction>, facts: ProjectFacts | undefined, blocks: Pick<BuildingBlock, "id">[]): AppliedModifications;
+export {};

package/dist/nl/typesafe-modify.js

@@ -0,0 +1,118 @@
+import { defaultParamsFor } from "../core/presets.js";
+import { SELECTABLE_BLOCKS, TYPESAFE_ENDPOINT, TYPESAFE_MODEL, THRESHOLDS } from "./typesafe-chooser.js";
+// `omh modify "request"` (#118) through Jev: one choice question per
+// selectable block ("what does the request ask for this block?"), answers
+// routed by confidence, applied as structured edits to harness.yaml. No
+// text is generated; params come from the detector or catalog defaults.
+export const MODIFY_ACTIONS = ["enable", "disable", "ask", "keep"];
+export function buildModifyRequest(input) {
+    const byId = new Map(input.blocks.map((b) => [b.id, b]));
+    const enabled = new Set(input.harness.hooks.map((h) => h.block));
+    const questions = {};
+    for (const id of SELECTABLE_BLOCKS) {
+        const b = byId.get(id);
+        if (!b)
+            continue;
+        const state = enabled.has(id) ? "currently ENABLED" : "currently DISABLED";
+        questions[`block:${id}`] = {
+            type: "choice",
+            instructions: `The user wants to change their guardrail configuration. Block '${id}' (${state}) ${lowerFirst(b.description)}. ` +
+                "What does the user's request ask for this block? Answer keep unless the request clearly refers to it.",
+            criteria: {
+                enable: "turn this block on (add it, or restore it to blocking mode)",
+                disable: "turn this block off entirely",
+                ask: "keep it but make it ask for confirmation instead of blocking",
+                keep: "the request does not concern this block",
+            },
+        };
+    }
+    return {
+        model: TYPESAFE_MODEL,
+        state: {
+            request: input.request,
+            currently_enabled: [...enabled],
+            ask_mode: input.harness.hooks.filter((h) => h.mode === "ask").map((h) => h.block),
+        },
+        questions,
+    };
+}
+export function routeModifyAnswers(answers) {
+    const out = new Map();
+    for (const [key, a] of Object.entries(answers)) {
+        if (!key.startsWith("block:") || a.type !== "choice")
+            continue;
+        const id = key.slice("block:".length);
+        if (!SELECTABLE_BLOCKS.includes(id))
+            continue;
+        const c = a;
+        if (!MODIFY_ACTIONS.includes(c.choice) || c.choice === "keep")
+            continue;
+        if (typeof c.confidence !== "number" || c.confidence < THRESHOLDS.choiceConfidence)
+            continue;
+        out.set(id, c.choice);
+    }
+    return out;
+}
+export async function modifyWithJev(input, opts) {
+    const res = await fetch(TYPESAFE_ENDPOINT, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify(buildModifyRequest(input)),
+        signal: AbortSignal.timeout(opts.timeoutMs ?? 15_000),
+    });
+    if (!res.ok) {
+        const body = (await res.text().catch(() => "")).slice(0, 200);
+        throw new Error(`TypeSafe API error ${res.status}: ${body || res.statusText}`);
+    }
+    const json = (await res.json());
+    return { decisions: routeModifyAnswers(json.answers ?? {}), usage: json.usage };
+}
+/** Apply decisions as structured edits. `locked: true` entries are never removed or weakened. */
+export function applyModifications(harness, decisions, facts, blocks) {
+    const known = new Set(blocks.map((b) => b.id));
+    const hooks = harness.hooks.map((h) => ({ ...h, params: { ...h.params } }));
+    const changes = [];
+    const refused = [];
+    for (const [block, action] of decisions) {
+        if (action === "keep" || !known.has(block))
+            continue;
+        const idx = hooks.findIndex((h) => h.block === block);
+        const existing = idx >= 0 ? hooks[idx] : undefined;
+        if (existing?.locked && (action === "disable" || action === "ask")) {
+            refused.push({ block, action, reason: `${block} is locked in harness.yaml; remove \`locked: true\` first` });
+            continue;
+        }
+        if (action === "disable") {
+            if (idx >= 0) {
+                hooks.splice(idx, 1);
+                changes.push({ block, action });
+            }
+        }
+        else if (action === "ask") {
+            if (existing && existing.mode !== "ask") {
+                existing.mode = "ask";
+                changes.push({ block, action });
+            }
+        }
+        else if (action === "enable") {
+            if (existing) {
+                if (existing.mode === "ask") {
+                    existing.mode = "block";
+                    changes.push({ block, action });
+                }
+                continue;
+            }
+            const params = defaultParamsFor(block, facts);
+            if (params === null) {
+                refused.push({ block, action, reason: `${block} needs a parameter the project detector could not supply; add it to harness.yaml by hand` });
+                continue;
+            }
+            hooks.push({ block, params, mode: "block" });
+            changes.push({ block, action });
+        }
+    }
+    return { harness: { ...harness, hooks }, changes, refused };
+}
+function lowerFirst(s) {
+    return s ? s[0].toLowerCase() + s.slice(1) : s;
+}

package/package.json

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