oh-my-harness 0.21.0 → 0.22.0

package/README.md

@@ -47,6 +47,12 @@ Because agents read instructions and then forget them halfway through a long ses
 # Zero-install: run directly with npx
 npx oh-my-harness init "TypeScript Next.js frontend with Python FastAPI backend"
 
+# No AI provider? Deterministic presets need nothing but the repo:
+npx oh-my-harness init --preset strict     # minimal | safe | strict
+
+# With a TypeSafe key, Jev tunes the preset to your description in one ~500 ms, sub-cent call:
+TYPESAFE_API_KEY=... npx oh-my-harness init "TypeScript API, TDD enforced, no auto PRs"
+
 # Or install globally
 npm install -g oh-my-harness
 oh-my-harness init "React app with TDD"
@@ -147,7 +153,8 @@ Hand omh a `WORKPLAN.md` and it runs one work order per fresh agent session, in
 
 ```bash
 # 🚀 Initialize
-omh init "your project description"      # NL-powered (requires AI provider)
+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 init                                  # Interactive TUI (import existing harness.yaml)
 
 # 📋 Catalog

package/dist/catalog/blocks/force-push-guard.js

@@ -2,9 +2,10 @@
 // `git push` when the destination is a protected branch and the push is
 // forced: --force / -f / a "+refspec". The destination
 // is the refspec's target (`origin main`, `origin HEAD:main`,
-// `origin feat:refs/heads/main`, `origin +main`); with no refspec it is the
-// current branch, and if that cannot be determined the push is blocked rather
-// than guessed. --force-with-lease is allowed by default (it refuses to
+// `origin feat:refs/heads/main`, `origin +main`), every refspec is checked;
+// with no refspec it is git's own push target (@{push}, so push.default=upstream
+// is honoured), falling back to the current branch, and if even that cannot be
+// determined the push is blocked rather than guessed. --force-with-lease is allowed by default (it refuses to
 // clobber unseen commits); set allowLease: false to block it too.
 export const forcePushGuard = {
     id: "force-push-guard",
@@ -40,9 +41,14 @@ _omh_cmd_matches "$COMMAND" git push || exit 0
 
 PROTECTED=({{#each protected}}"{{{this}}}" {{/each}})
 CURRENT=$(git branch --show-current 2>/dev/null || echo "")
+# With no refspec git pushes to the configured target, which under
+# push.default=upstream can be a different branch than HEAD (feature -> main).
+PUSH_TARGET=$(git rev-parse --abbrev-ref --symbolic-full-name '@{push}' 2>/dev/null || echo "")
+PUSH_TARGET="\${PUSH_TARGET#*/}"
+[[ -z "$PUSH_TARGET" ]] && PUSH_TARGET="$CURRENT"
 
 HIT=$(_omh_simple_commands "$COMMAND" | awk -F '\\t' \\
-  -v protected="$(IFS='|'; printf '%s' "\${PROTECTED[*]}")" -v current="$CURRENT" -v allow_lease="{{allowLease}}" '
+  -v protected="$(IFS='|'; printf '%s' "\${PROTECTED[*]}")" -v current="$PUSH_TARGET" -v allow_lease="{{allowLease}}" '
   BEGIN { np = split(protected, P, "|"); for (k = 1; k <= np; k++) isp[P[k]] = 1 }
   found != "" { next }
   {
@@ -53,26 +59,30 @@ HIT=$(_omh_simple_commands "$COMMAND" | awk -F '\\t' \\
     j = i + 1
     while (j <= NF && $j ~ /^-/) { if ($j == "-c" || $j == "-C") j++; j++ }
     if (j > NF || $j != "push") next
-    force = 0; lease = 0; remote = ""; refspec = ""; plus = 0
+    force = 0; lease = 0; remote = ""; nref = 0; plus = 0
     for (k = j + 1; k <= NF; k++) {
       t = $k
-      if (t == "--") { for (m = k + 1; m <= NF; m++) { if (remote == "") remote = $m; else if (refspec == "") refspec = $m }; break }
+      if (t == "--") { for (m = k + 1; m <= NF; m++) { if (remote == "") remote = $m; else refs[++nref] = $m }; break }
       if (t == "--force" || t == "-f" || t ~ /^-[A-Za-z]*f[A-Za-z]*$/) { force = 1; continue }
       if (t == "--force-if-includes") continue   # only modifies --force-with-lease; not a force on its own
       if (t ~ /^--force-with-lease/) { lease = 1; continue }
       if (t ~ /^--repo=/) { remote = substr(t, 8); continue }
       if (t == "--repo" || t == "-o" || t == "--push-option" || t == "--receive-pack" || t == "--exec") { k++; continue }
       if (t ~ /^-/) continue
-      if (remote == "") remote = t; else if (refspec == "") refspec = t
+      if (remote == "") remote = t; else refs[++nref] = t
+    }
+    # git pushes every refspec given; any protected destination is enough to block
+    if (nref == 0) refs[++nref] = ""
+    for (r = 1; r <= nref; r++) {
+      dst = refs[r]; plus = 0
+      if (substr(dst, 1, 1) == "+") { plus = 1; dst = substr(dst, 2) }   # "+refspec" forces without --force
+      if (index(dst, ":") > 0) dst = substr(dst, index(dst, ":") + 1)
+      sub(/^refs\\/heads\\//, "", dst)
+      if (!force && !plus && !(lease && allow_lease == "false")) continue
+      if (dst == "HEAD" || dst == "") dst = current
+      if (dst == "") { found = "force push with an undeterminable target branch"; break }
+      if (isp[dst]) { found = "force push to " dst; break }
     }
-    dst = refspec
-    if (substr(dst, 1, 1) == "+") { plus = 1; dst = substr(dst, 2) }   # "+refspec" forces without --force
-    if (index(dst, ":") > 0) dst = substr(dst, index(dst, ":") + 1)
-    sub(/^refs\\/heads\\//, "", dst)
-    if (!force && !plus && !(lease && allow_lease == "false")) next
-    if (dst == "HEAD" || dst == "") dst = current
-    if (dst == "") { found = "force push with an undeterminable target branch"; next }
-    if (isp[dst]) found = "force push to " dst
   }
   END { if (found != "") print found }')
 

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

@@ -3,7 +3,7 @@
 // commands that would rewrite, delete or neuter them: file tools with a
 // protected path as an argument, output redirections into a protected path,
 // and git checkout/restore/clean/rm/mv on one. Read-only commands (cat, grep,
-// ls, diff) stay allowed so the agent can inspect its own rules, and `omh` is
+// ls, diff, sed without -i) stay allowed so the agent can inspect its own rules, and `omh` is
 // never a writer here, so `omh sync` / `omh hook add` remain the sanctioned
 // way to change the harness.
 // ponytail: harness.yaml itself is deliberately not protected (it is the
@@ -37,7 +37,7 @@ COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
 [[ -z "$COMMAND" ]] && exit 0
 
 PROTECTED=(".omh" ".claude/settings.json" ".codex/hooks.json" ".codex/config.toml" ".pi/extensions/omh-harness.ts" {{#each extraPaths}}"{{{this}}}" {{/each}})
-WRITERS="rm mv cp sed tee chmod chown chgrp truncate dd ln touch install rsync shred unlink perl"
+WRITERS="rm mv cp tee chmod chown chgrp truncate dd ln touch install rsync shred unlink perl"
 GIT_WRITERS="checkout restore clean rm mv"
 
 HIT=$(_omh_simple_commands "$COMMAND" | awk -F '\\t' \\
@@ -69,6 +69,13 @@ HIT=$(_omh_simple_commands "$COMMAND" | awk -F '\\t' \\
     a0 = $i
     write = 0
     if (isw[a0]) write = 1
+    else if (a0 == "sed") {   # sed only writes in place: -i, any -i cluster, --in-place or a GNU abbreviation of it (--i, --in-p ...)
+      for (k = i + 1; k <= NF; k++) {
+        if ($k == "--") break
+        if ($k ~ /^-[A-Za-z]*i/) { write = 1; break }
+        if ($k ~ /^--i/) { o = $k; sub(/=.*/, "", o); if (index("--in-place", o) == 1) { write = 1; break } }
+      }
+    }
     else if (a0 == "git") {
       j = i + 1; while (j <= NF && $j ~ /^-/) { if ($j == "-c" || $j == "-C") j++; j++ }
       if (j <= NF && isg[$j]) write = 1

package/dist/catalog/blocks/no-verify-guard.js

@@ -5,7 +5,8 @@
 // or `git push` (through env/sudo/sh -c, see #109/#110):
 //   git commit --no-verify | -n | any short cluster containing n (-anm, -qn)
 //   git push --no-verify
-//   git -c core.hooksPath=... <anything>   (points hooks at an empty dir)
+//   git -c core.hooksPath=... <anything>   (points hooks at an empty dir; key match is case-insensitive)
+//   GIT_CONFIG_KEY_n=core.hooksPath ... git  and GIT_CONFIG_PARAMETERS='core.hooksPath=...' git
 // `git push -n` is dry-run, not no-verify, so it stays allowed.
 export const noVerifyGuard = {
     id: "no-verify-guard",
@@ -27,14 +28,21 @@ HIT=$(_omh_simple_commands "$COMMAND" | awk -F '\\t' '
   found != "" { next }
   {
     i = 1
-    while (i <= NF && $i ~ /^[A-Za-z_][A-Za-z0-9_]*=/) i++
+    env_bypass = 0
+    while (i <= NF && $i ~ /^[A-Za-z_][A-Za-z0-9_]*=/) {
+      # GIT_CONFIG_KEY_n=core.hooksPath / GIT_CONFIG_PARAMETERS='core.hooksPath=...' disable hooks too
+      lw = tolower($i)
+      if (lw ~ /^git_config_key_[0-9]+=core\\.hookspath$/ || lw ~ /^git_config_parameters=.*core\\.hookspath=/) env_bypass = 1
+      i++
+    }
     if (i <= NF && ($i == "sudo" || $i == "doas")) { i++; while (i <= NF && $i ~ /^-/) i++ }
     if (i > NF || $i != "git") next
-    # global options before the subcommand; -c core.hooksPath=... is itself a bypass
+    if (env_bypass) { found = "GIT_CONFIG core.hooksPath override"; next }
+    # global options before the subcommand; -c core.hooksPath=... is itself a bypass (config keys are case-insensitive)
     j = i + 1
     while (j <= NF && $j ~ /^-/) {
       if ($j == "-c" || $j == "-C") {
-        if ($j == "-c" && j + 1 <= NF && $(j + 1) ~ /^core\\.hooksPath=/) { found = "git -c core.hooksPath override"; next }
+        if ($j == "-c" && j + 1 <= NF && tolower($(j + 1)) ~ /^core\\.hookspath=/) { found = "git -c core.hooksPath override"; next }
         j++
       }
       j++

package/dist/cli/commands/config.js

@@ -1,6 +1,13 @@
 import chalk from "chalk";
+import { resolveTypesafeApiKey } from "../../nl/typesafe-chooser.js";
 import { loadProviderConfig, deleteProviderConfig, maskApiKey, } from "../../nl/config-store.js";
 const NO_CONFIG_MESSAGE = "No AI provider configured yet. Run `omh config` (or `omh init`) to set one up.";
+function printChooserLine() {
+    const key = resolveTypesafeApiKey(process.cwd());
+    console.log(key
+        ? `  chooser:  ${chalk.cyan("TypeSafe Jev")} ${chalk.dim("(TYPESAFE_API_KEY found; `omh init \"...\"` selects catalog blocks with it, no LLM call)")}`
+        : `  chooser:  ${chalk.dim("none (set TYPESAFE_API_KEY to let Jev pick catalog blocks; `omh init --preset` needs neither)")}`);
+}
 function printSummary(config) {
     console.log(chalk.bold("Current AI provider configuration:"));
     console.log(`  provider: ${chalk.cyan(config.provider)}`);
@@ -53,15 +60,18 @@ export async function configCommand(options = {}) {
     if (options.show) {
         if (!existing) {
             console.log(NO_CONFIG_MESSAGE);
+            printChooserLine();
             return { exitCode: 0 };
         }
         printSummary(existing);
+        printChooserLine();
         return { exitCode: 0 };
     }
     // --reset: delete the saved config.
     if (options.reset) {
         if (!existing) {
             console.log(NO_CONFIG_MESSAGE);
+            printChooserLine();
             return { exitCode: 0 };
         }
         const confirm = options.confirm ?? defaultConfirm;
@@ -78,6 +88,7 @@ export async function configCommand(options = {}) {
     // `omh config` is a safe read; `--yes` skips the prompt.
     if (existing) {
         printSummary(existing);
+        printChooserLine();
         console.log("");
         if (!options.yes) {
             const confirm = options.confirm ?? defaultConfirm;

package/dist/cli/commands/doctor.js

@@ -4,6 +4,7 @@ import { parse } from "smol-toml";
 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";
 export async function doctorCommand(options = {}) {
     const projectDir = options.projectDir ?? process.cwd();
     const messages = [];
@@ -158,7 +159,7 @@ export async function doctorCommand(options = {}) {
     // 9. AI provider config (~/.omh/config.json). Global and optional, so this is
     // purely informational (INFO) and never affects health — it just surfaces
     // `omh config` so users can rotate an expired key or switch provider/model.
-    const providerConfigured = await checkProviderConfig(messages);
+    const providerConfigured = await checkProviderConfig(messages, projectDir);
     const checksHealthy = Object.values(checks).every(Boolean);
     const healthy = checksHealthy && (!options.strict || inSync !== false);
     const exitCode = healthy ? 0 : 1;
@@ -180,10 +181,16 @@ export async function doctorCommand(options = {}) {
  * Inspects the global AI provider config and appends an INFO hint to `messages`.
  * Returns whether a provider is configured. Never reads or echoes the API key.
  */
-async function checkProviderConfig(messages) {
+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.");
+    }
     const config = await loadProviderConfig();
     if (!config) {
-        messages.push("INFO: No AI provider configured for natural-language mode — run `omh config` to set one up.");
+        messages.push(jev
+            ? "INFO: LLM provider: none (optional; only needed for generated rule text — `omh config` to add one)."
+            : "INFO: No AI provider configured for natural-language mode — run `omh config` to set one up, or use `omh init --preset`.");
         return false;
     }
     if (config.method === "api") {

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

@@ -4,6 +4,8 @@ export interface InitOptions {
     projectDir?: string;
     nlRunner?: ClaudeRunner;
     description?: string;
+    /** Deterministic preset (#116): minimal | safe | strict. No provider, no network. */
+    preset?: string;
 }
 export interface HarnessState {
     presets: string[];

package/dist/cli/commands/init.js

@@ -2,7 +2,10 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import yaml from "js-yaml";
 import { generate } from "../../core/generator.js";
-import { generateHarnessConfig } from "../../nl/parse-intent.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 { 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";
 import { createDefaultRegistry } from "../../catalog/registry.js";
@@ -32,7 +35,9 @@ export async function initCommand(descriptionParts, options = {}) {
     if (inlineDescription) {
         options = { ...options, description: inlineDescription };
     }
-    if (options.nlRunner || options.yes) {
+    // Anything that already says what to build skips the TUI; initWithNL still
+    // asks "Proceed?" unless -y was given.
+    if (options.nlRunner || options.yes || options.preset || options.description) {
         await initWithNL(projectDir, options);
         return;
     }
@@ -41,25 +46,29 @@ export async function initCommand(descriptionParts, options = {}) {
 }
 export const initCommandHeadless = initCommand;
 export async function initWithNL(projectDir, options) {
-    let description;
-    if (options.yes && (options.description || options.nlRunner)) {
-        description = options.description ?? "generate config";
+    if (options.preset !== undefined && !isPresetName(options.preset)) {
+        throw new Error(`Unknown preset "${options.preset}". Valid presets: ${PRESET_NAMES.join(", ")}`);
     }
-    else if (!options.yes) {
+    const preset = options.preset;
+    let description = options.description?.trim() ?? "";
+    if (!description && options.nlRunner)
+        description = "generate config";
+    if (!description && !preset) {
+        if (options.yes) {
+            console.log("No description provided.");
+            return;
+        }
         const { input } = await import("@inquirer/prompts");
-        description = await input({
+        description = (await input({
             message: "Describe your project (e.g., 'Next.js e-commerce app with Stripe'):",
-        });
-        if (!description.trim()) {
+        })).trim();
+        if (!description) {
             console.log("No description provided.");
             return;
         }
     }
-    else {
-        console.log("No description provided.");
-        return;
-    }
-    console.log(`Generating harness config for: "${description}"`);
+    if (description)
+        console.log(`Generating harness config for: "${description}"`);
     let facts;
     try {
         facts = await detectProject(projectDir);
@@ -76,7 +85,51 @@ export async function initWithNL(projectDir, options) {
         matcher: b.matcher,
         params: b.params.map((p) => ({ name: p.name, type: p.type, description: p.description, required: p.required, default: p.default })),
     }));
-    const harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks, facts);
+    // Which generator? --preset always wins and stays offline and deterministic;
+    // then an injected LLM runner (tests); then Jev when a TYPESAFE_API_KEY is
+    // around and there is a description to judge; then a configured LLM
+    // provider; and with none of those, the "safe" preset with a hint instead
+    // of a provider-setup error (#116, #129).
+    const typesafeKey = resolveTypesafeApiKey(projectDir);
+    const registryBlocks = registry.list();
+    let harness;
+    if (preset) {
+        harness = buildPresetHarness(preset, facts, { description: description || undefined });
+        console.log(`preset: ${preset}`);
+    }
+    else if (options.nlRunner) {
+        harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks, facts);
+    }
+    else if (typesafeKey && description) {
+        try {
+            const result = await chooseWithJev({ description, facts, blocks: registryBlocks }, { apiKey: typesafeKey });
+            const applied = harnessFromChoices(result, facts, { description });
+            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);
+            console.log(`Jev (${TYPESAFE_MODEL}) chose: strictness=${result.strictness}, ${result.usage?.input_tokens ?? "?"} input tokens`);
+            console.log(`  enabled:   ${on.join(", ") || "none"}`);
+            console.log(`  disabled:  ${off.join(", ") || "none"}`);
+            if (undecided.length)
+                console.log(`  undecided: ${undecided.join(", ")} (kept as the preset has them)`);
+            for (const s of applied.skipped)
+                console.log(`  skipped:   ${s.reason}`);
+            const { skipped: _skipped, ...rest } = applied;
+            harness = rest;
+        }
+        catch (err) {
+            console.log(`TypeSafe chooser unavailable (${err.message}); using the "safe" preset instead.`);
+            harness = buildPresetHarness("safe", facts, { description });
+        }
+    }
+    else if ((await hasProviderConfig()) || providerConfigFromEnv()) {
+        harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks, facts);
+    }
+    else {
+        harness = buildPresetHarness("safe", facts, { description });
+        console.log('No AI provider and no TYPESAFE_API_KEY found; using the "safe" preset.');
+        console.log(`  Pick one explicitly with --preset ${PRESET_NAMES.join("|")}, set TYPESAFE_API_KEY to let Jev tune it, or run \`omh config\` for an LLM provider.`);
+    }
     const stackNames = harness.project.stacks.map((s) => `${s.name} (${s.framework})`).join(", ");
     console.log(`\nStacks: ${stackNames}`);
     console.log(`Rules: ${harness.rules.length}`);

package/dist/cli/commands/test.js

@@ -6,7 +6,7 @@ import yaml from "js-yaml";
 import { getRegisteredHooks, generateBlockTestCases, runTestCase } from "../harness-tester.js";
 import { checkHarnessCommands } from "../command-checker.js";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
-import { mergeEnforcementAndHooks } from "../../core/harness-converter-v2.js";
+import { effectiveHookEntries } from "../../core/harness-converter-v2.js";
 import { builtinBlocks } from "../../catalog/blocks/index.js";
 export function formatCategoryName(category) {
     const names = {
@@ -38,7 +38,7 @@ export async function testCommand(options = {}) {
         const result = HarnessConfigSchema.safeParse(parsed);
         if (result.success) {
             // Merge enforcement-derived hooks with explicit hooks
-            hookEntries = mergeEnforcementAndHooks(result.data);
+            hookEntries = effectiveHookEntries(result.data, { has: (id) => builtinBlocks.some((b) => b.id === id) });
         }
         else {
             console.log(chalk.yellow(`Warning: harness.yaml schema validation failed: ${result.error.message}`));
@@ -85,8 +85,23 @@ export async function testCommand(options = {}) {
     catch {
         // git 없으면 undefined
     }
-    // Generate test cases from block-based hooks only
-    const testCases = generateBlockTestCases(hookEntries, builtinBlocks, currentBranch);
+    // Generate test cases from block-based hooks only. A case whose hook script
+    // is not on disk (harness.yaml ahead of `omh sync`) is reported as skipped
+    // rather than failed, so the dry run stays about hook behaviour.
+    const allCases = generateBlockTestCases(hookEntries, builtinBlocks, currentBranch, hooks);
+    const testCases = [];
+    const missingScripts = new Set();
+    for (const tc of allCases) {
+        try {
+            await fs.access(path.isAbsolute(tc.hookScript) ? tc.hookScript : path.join(projectDir, tc.hookScript));
+            testCases.push(tc);
+        }
+        catch {
+            missingScripts.add(tc.hookScript);
+        }
+    }
+    for (const s of missingScripts)
+        console.log(chalk.dim(`  skipped: ${s} not found (run \`omh sync\`)`));
     const results = [];
     // 카테고리별 그룹핑
     const categories = [...new Set(testCases.map((tc) => tc.category))];

package/dist/cli/harness-tester.js

@@ -213,18 +213,22 @@ export function generateBlockTestCases(hookEntries, blocks, currentBranch, regis
                 break;
             }
             case "force-push-guard": {
+                const protectedBranches = params.protected ?? [];
+                const target = protectedBranches[0];
+                if (target) {
+                    cases.push({
+                        name: `"git push --force origin ${target}" → BLOCKED`,
+                        category: "force-push-guard",
+                        hookScript,
+                        input: { tool_name: "Bash", tool_input: { command: `git push --force origin ${target}` } },
+                        expectation: "block",
+                    });
+                }
                 cases.push({
-                    name: '"git push --force origin main" → BLOCKED',
-                    category: "force-push-guard",
-                    hookScript,
-                    input: { tool_name: "Bash", tool_input: { command: "git push --force origin main" } },
-                    expectation: "block",
-                });
-                cases.push({
-                    name: '"git push origin main" → ALLOWED',
+                    name: `"git push origin ${target ?? "main"}" → ALLOWED`,
                     category: "force-push-guard",
                     hookScript,
-                    input: { tool_name: "Bash", tool_input: { command: "git push origin main" } },
+                    input: { tool_name: "Bash", tool_input: { command: `git push origin ${target ?? "main"}` } },
                     expectation: "allow",
                 });
                 break;

package/dist/cli/index.js

@@ -24,9 +24,16 @@ export function createCli() {
         .command("init [description...]")
         .description("Initialize harness from a project description")
         .option("-y, --yes", "Skip confirmation prompts")
+        .option("--preset <name>", "Deterministic setup with no AI provider: minimal | safe | strict (Jev tunes it when TYPESAFE_API_KEY is set)")
         .action(async (description, options) => {
         const { initCommand } = await import("./commands/init.js");
-        await initCommand(description, options);
+        try {
+            await initCommand(description, options);
+        }
+        catch (err) {
+            console.error(`error: ${err.message}`);
+            process.exitCode = 1;
+        }
     });
     program
         .command("doctor")

package/dist/cli/stats/data.js

@@ -1,5 +1,6 @@
 import { readEvents, aggregateStats } from "../event-logger.js";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
+import { effectiveHookEntries } from "../../core/harness-converter-v2.js";
 import { builtinBlocks } from "../../catalog/blocks/index.js";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -107,7 +108,7 @@ export async function loadStatsData(projectDir, dateRange = "all") {
         const parsed = yaml.load(raw);
         const result = HarnessConfigSchema.safeParse(parsed);
         if (result.success) {
-            hookEntries = result.data.hooks ?? [];
+            hookEntries = effectiveHookEntries(result.data, { has: (id) => builtinBlocks.some((b) => b.id === id) });
         }
     }
     catch {

package/dist/cli/tui/init-flow.d.ts

@@ -1,6 +1,17 @@
 import type { DepCheck } from "../deps-checker.js";
 import type { HarnessConfig } from "../../core/harness-schema.js";
 import type { ProjectFacts } from "../../detector/types.js";
+export type ModeValue = "nl" | "preset" | "import";
+/** Mode menu for the TUI; the AI entry says what will actually run (QA). */
+export declare function buildModeOptions(ctx: {
+    claudeInstalled: boolean;
+    providerConfigured: boolean;
+    jevKey: boolean;
+}): Array<{
+    value: ModeValue;
+    label: string;
+    hint?: string;
+}>;
 export declare function formatDepResults(deps: DepCheck[]): string;
 export declare function formatConfigSummary(config: HarnessConfig): string;
 export declare function formatProjectFacts(facts: ProjectFacts): string;

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

@@ -7,13 +7,28 @@ import { checkDependencies } from "../deps-checker.js";
 import { checkReferencedTools } from "../tool-checker.js";
 import { writeHarnessState } from "../commands/init.js";
 import { generate } from "../../core/generator.js";
-import { generateHarnessConfig, createDefaultRunner } from "../../nl/parse-intent.js";
+import { generateHarnessConfig, createDefaultRunner, providerConfigFromEnv } from "../../nl/parse-intent.js";
+import { buildPresetHarness, PRESET_NAMES } from "../../core/presets.js";
+import { chooseWithJev, harnessFromChoices, resolveTypesafeApiKey, TYPESAFE_MODEL } from "../../nl/typesafe-chooser.js";
 import { hasProviderConfig } from "../../nl/config-store.js";
 import { runProviderSetup } from "./provider-setup.js";
 import { mergeEnforcementAndHooks } from "../../core/harness-converter-v2.js";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
 import { detectProject } from "../../detector/project-detector.js";
 import { hasStarPromptBeenShown, markStarPromptShown, starRepo } from "../github-star.js";
+/** Mode menu for the TUI; the AI entry says what will actually run (QA). */
+export function buildModeOptions(ctx) {
+    const nl = ctx.jevKey
+        ? { value: "nl", label: "Describe your project (Jev picks the blocks, no LLM)" }
+        : ctx.providerConfigured || ctx.claudeInstalled
+            ? { value: "nl", label: "Describe your project (AI-powered)" }
+            : { value: "nl", label: "Describe your project (AI-powered)", hint: "needs an AI provider or TYPESAFE_API_KEY" };
+    return [
+        nl,
+        { value: "preset", label: "Use a preset (no AI): minimal | safe | strict" },
+        { value: "import", label: "Import existing harness.yaml" },
+    ];
+}
 export function formatDepResults(deps) {
     if (deps.length === 0)
         return "";
@@ -129,32 +144,41 @@ export async function runInitTUI(options) {
     }
     if (projectFacts)
         p.note(formatProjectFacts(projectFacts), "Detected Project");
-    const modeOptions = [
-        claudeInstalled
-            ? { value: "nl", label: "Describe your project (AI-powered)" }
-            : { value: "nl", label: "Describe your project (AI-powered)", hint: "requires claude CLI" },
-        { value: "import", label: "Import existing harness.yaml" },
-    ];
+    // Mode Selection
+    const jevKey = resolveTypesafeApiKey(projectDir);
+    const providerConfigured = (await hasProviderConfig()) || Boolean(providerConfigFromEnv());
+    const modeOptions = buildModeOptions({ claudeInstalled, providerConfigured, jevKey: Boolean(jevKey) });
     const mode = await p.select({ message: "How would you like to configure your harness?", options: modeOptions });
     handleCancel(mode);
-    if (mode === "nl" && !claudeInstalled) {
-        p.log.error("claude CLI is required for AI-powered mode. Install it with:");
-        p.log.info("  npm install -g @anthropic-ai/claude-code");
-        p.cancel("Cannot proceed without claude CLI.");
-        process.exit(1);
-    }
     let harnessConfig;
-    if (mode === "nl") {
-        const hasConfig = await hasProviderConfig();
-        if (!hasConfig) {
-            p.log.info("No AI provider configured yet. Let's set one up.");
+    if (mode === "preset") {
+        const preset = await p.select({
+            message: "Which preset?",
+            options: [
+                { value: "safe", label: "safe", hint: "commit gates, lockfile/secret guards, lint on save" },
+                { value: "strict", label: "strict", hint: "safe + test-first (TDD) on every source edit" },
+                { value: "minimal", label: "minimal", hint: "dangerous commands, main branch, build output only" },
+            ],
+        });
+        handleCancel(preset);
+        harnessConfig = buildPresetHarness(preset, projectFacts);
+        p.note(formatConfigSummary(harnessConfig), `Preset: ${preset}`);
+        const confirmed = await p.confirm({ message: "Proceed with this configuration?", initialValue: true });
+        handleCancel(confirmed);
+        if (!confirmed) {
+            p.cancel("Aborted.");
+            process.exit(0);
+        }
+    }
+    else if (mode === "nl") {
+        if (!jevKey && !providerConfigured && !claudeInstalled) {
+            p.log.info("No AI provider configured yet. Let's set one up (or pick a preset instead).");
             const providerConfig = await runProviderSetup();
             if (!providerConfig) {
                 p.cancel("Provider setup cancelled.");
                 process.exit(0);
             }
         }
-        const runner = await createDefaultRunner();
         const description = await p.text({
             message: "Describe your project:",
             placeholder: "e.g., Next.js e-commerce app with Stripe and Tailwind",
@@ -163,21 +187,34 @@ export async function runInitTUI(options) {
         });
         handleCancel(description);
         const genSpinner = p.spinner();
-        genSpinner.start("Generating harness configuration...");
+        genSpinner.start(jevKey ? `Asking Jev (${TYPESAFE_MODEL}) which blocks fit...` : "Generating harness configuration...");
         try {
             const { createDefaultRegistry } = await import("../../catalog/registry.js");
             const catalogRegistry = await createDefaultRegistry();
-            const catalogBlocks = catalogRegistry.list().map((b) => ({
-                id: b.id,
-                description: b.description,
-                params: b.params.map((pp) => ({ name: pp.name, required: pp.required, default: pp.default, description: pp.description })),
-            }));
-            harnessConfig = await generateHarnessConfig(description, runner, catalogBlocks, projectFacts);
-            genSpinner.stop("Configuration generated");
+            if (jevKey) {
+                const result = await chooseWithJev({ description: description, facts: projectFacts, blocks: catalogRegistry.list() }, { apiKey: jevKey });
+                const applied = harnessFromChoices(result, projectFacts, { description: description });
+                const { skipped, ...rest } = applied;
+                harnessConfig = rest;
+                genSpinner.stop(`Jev chose strictness=${result.strictness} (${result.usage?.input_tokens ?? "?"} input tokens)`);
+                for (const s of skipped)
+                    p.log.warn(`skipped: ${s.reason}`);
+            }
+            else {
+                const runner = await createDefaultRunner();
+                const catalogBlocks = catalogRegistry.list().map((b) => ({
+                    id: b.id,
+                    description: b.description,
+                    params: b.params.map((pp) => ({ name: pp.name, required: pp.required, default: pp.default, description: pp.description })),
+                }));
+                harnessConfig = await generateHarnessConfig(description, runner, catalogBlocks, projectFacts);
+                genSpinner.stop("Configuration generated");
+            }
         }
         catch (err) {
             genSpinner.stop("Generation failed");
             p.log.error(`Failed to generate config: ${err.message}`);
+            p.log.info(`Tip: \`omh init --preset ${PRESET_NAMES.join("|")}\` needs no provider.`);
             p.cancel("Try again.");
             process.exit(1);
         }

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

@@ -2,5 +2,15 @@ import type { HarnessConfig } from "./harness-schema.js";
 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[];
 export declare function mergeEnforcementAndHooks(harness: HarnessConfig): HookEntry[];
 export declare function harnessToMergedConfigV2(harness: HarnessConfig, registry?: CatalogRegistry, projectDir?: string): Promise<MergedConfig>;

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

@@ -55,6 +55,48 @@ function convertEnforcementToHooks(enforcement) {
     }
     return hooks;
 }
+// A harness that enforces anything also guards itself: without this an agent
+// could delete or rewrite the hooks through Bash (#113), skip git hooks or
+// force-push main (#98, #99, #114). An explicit entry keeps its mode/params;
+// custom registries without the block are skipped.
+export const ALWAYS_ON_GUARDS = ["harness-guard", "no-verify-guard", "force-push-guard"];
+function addAlwaysOnGuards(entries, registry) {
+    if (entries.length === 0)
+        return;
+    for (const id of ALWAYS_ON_GUARDS) {
+        if (registry.has(id) && !entries.some((h) => h.block === id)) {
+            entries.push({ block: id, params: {}, mode: "block" });
+        }
+    }
+}
+// The loop engine brings its guard along. An explicit loop-guard entry may
+// choose its mode, but the paths it protects always come from the loop
+// config — otherwise an empty explicit entry would silently unguard the
+// real work-order directory.
+function addLoopGuard(entries, harness) {
+    if (!harness.loop?.enabled)
+        return;
+    const loopParams = { workOrders: harness.loop.workOrders, architectOnly: harness.loop.architectOnly };
+    const explicit = entries.find((h) => h.block === "loop-guard");
+    if (explicit) {
+        explicit.params = { ...explicit.params, ...loopParams };
+    }
+    else {
+        entries.push({ block: "loop-guard", params: loopParams, mode: "block" });
+    }
+}
+/**
+ * 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 function effectiveHookEntries(harness, registry) {
+    const entries = mergeEnforcementAndHooks(harness);
+    addLoopGuard(entries, harness);
+    addAlwaysOnGuards(entries, registry);
+    return entries;
+}
 export function mergeEnforcementAndHooks(harness) {
     const enforcementHooks = convertEnforcementToHooks(harness.enforcement);
     const explicitHooks = harness.hooks ?? [];
@@ -75,38 +117,14 @@ export async function harnessToMergedConfigV2(harness, registry, projectDir) {
     const base = harnessToMergedConfig(harness);
     // Merge enforcement-derived hooks with explicit hooks (dedup by block id)
     const allHookEntries = mergeEnforcementAndHooks(harness);
-    // The loop engine brings its guard along. An explicit loop-guard entry may
-    // choose its mode, but the paths it protects always come from the loop
-    // config — otherwise an empty explicit entry would silently unguard the
-    // real work-order directory.
-    if (harness.loop?.enabled) {
-        const loopParams = { workOrders: harness.loop.workOrders, architectOnly: harness.loop.architectOnly };
-        const explicit = allHookEntries.find((h) => h.block === "loop-guard");
-        if (explicit) {
-            explicit.params = { ...explicit.params, ...loopParams };
-        }
-        else {
-            allHookEntries.push({ block: "loop-guard", params: loopParams, mode: "block" });
-        }
-    }
+    addLoopGuard(allHookEntries, harness);
     // If no hook entries at all, return base config unchanged
     if (allHookEntries.length === 0) {
         return { ...base };
     }
     // Resolve registry — use provided one or create the default
     const resolvedRegistry = registry ?? (await createDefaultRegistry());
-    // A harness that enforces anything also guards itself: without this an
-    // agent could delete or rewrite the hooks through Bash (#113). An explicit
-    // entry may change its mode or add paths. Skipped for custom registries
-    // that do not ship the block.
-    // Same rule for the git-safety pair (#114): a harness that enforces anything
-    // gets no-verify-guard and force-push-guard on every runtime, instead of the
-    // Claude-only permissions.deny list the NL prompt sometimes emitted.
-    for (const id of ["harness-guard", "no-verify-guard", "force-push-guard"]) {
-        if (resolvedRegistry.has(id) && !allHookEntries.some((h) => h.block === id)) {
-            allHookEntries.push({ block: id, params: {}, mode: "block" });
-        }
-    }
+    addAlwaysOnGuards(allHookEntries, resolvedRegistry);
     const catalogResult = await convertHookEntries(allHookEntries, resolvedRegistry, projectDir ?? ".");
     // Convert hooksConfig entries from catalog into HookDefinition format.
     // Errors are reported as warnings but don't block valid hooks.

package/dist/core/presets.d.ts

@@ -0,0 +1,17 @@
+import { type HarnessConfig } from "./harness-schema.js";
+import type { ProjectFacts } from "../detector/types.js";
+export type PresetName = "minimal" | "safe" | "strict";
+export declare const PRESET_NAMES: PresetName[];
+export declare function isPresetName(v: string): v is PresetName;
+type Params = Record<string, unknown>;
+/**
+ * Params for a block, filled from the detector facts. `null` means a required
+ * param has no source and the block must not be enabled. `{}` means the
+ * catalog defaults are enough.
+ */
+export declare function defaultParamsFor(blockId: string, facts?: ProjectFacts): Params | null;
+export declare function buildPresetHarness(preset: PresetName, facts?: ProjectFacts, meta?: {
+    name?: string;
+    description?: string;
+}): HarnessConfig;
+export {};

package/dist/core/presets.js

@@ -0,0 +1,125 @@
+import { HarnessConfigSchema } from "./harness-schema.js";
+export const PRESET_NAMES = ["minimal", "safe", "strict"];
+export function isPresetName(v) {
+    return PRESET_NAMES.includes(v);
+}
+// Per-language file patterns for the blocks that need them.
+const LANG = {
+    typescript: { src: "\\.(ts|tsx|js|jsx)$", test: "\\.(test|spec)\\.(ts|tsx|js|jsx)$", glob: "*.ts", tddDefault: true },
+    javascript: { src: "\\.(ts|tsx|js|jsx)$", test: "\\.(test|spec)\\.(ts|tsx|js|jsx)$", glob: "*.js", tddDefault: true },
+    python: { src: "\\.py$", test: "(^|/)(test_[^/]*|[^/]*_test)\\.py$", glob: "*.py" },
+    go: { src: "\\.go$", test: "_test\\.go$", glob: "*.go" },
+    rust: { src: "\\.rs$", test: "(tests/.*|_test)\\.rs$", glob: "*.rs" },
+    swift: { src: "\\.swift$", test: "Tests?\\.swift$", glob: "*.swift" },
+    kotlin: { src: "\\.kt$", test: "Test\\.kt$", glob: "*.kt" },
+    java: { src: "\\.java$", test: "Test\\.java$", glob: "*.java" },
+    ruby: { src: "\\.rb$", test: "_spec\\.rb$", glob: "*.rb" },
+    php: { src: "\\.php$", test: "Test\\.php$", glob: "*.php" },
+    dart: { src: "\\.dart$", test: "_test\\.dart$", glob: "*.dart" },
+    elixir: { src: "\\.exs?$", test: "_test\\.exs$", glob: "*.ex" },
+    scala: { src: "\\.scala$", test: "(Spec|Test)\\.scala$", glob: "*.scala" },
+};
+function lang(facts) {
+    const l = facts?.languages?.[0]?.toLowerCase() ?? "";
+    return LANG[l] ?? LANG.typescript;
+}
+/**
+ * Params for a block, filled from the detector facts. `null` means a required
+ * param has no source and the block must not be enabled. `{}` means the
+ * catalog defaults are enough.
+ */
+export function defaultParamsFor(blockId, facts) {
+    const l = lang(facts);
+    switch (blockId) {
+        case "commit-test-gate":
+            return facts?.testCommands?.[0] ? { testCommand: facts.testCommands[0] } : null;
+        case "commit-typecheck-gate":
+            return facts?.typecheckCommands?.[0] ? { typecheckCommand: facts.typecheckCommands[0] } : null;
+        case "lint-on-save":
+            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 "format-on-save":
+            return null; // no formatter detection yet; ponytail: add when the detector learns formatters
+        case "path-guard":
+            return facts?.blockedPaths?.length ? { blockedPaths: [...facts.blockedPaths] } : null;
+        case "tdd-guard":
+            return l.tddDefault ? {} : { srcPattern: l.src, testPattern: l.test };
+        default:
+            return {};
+    }
+}
+const HOOKS_BY_PRESET = {
+    minimal: ["branch-guard", "command-guard", "path-guard"],
+    safe: ["branch-guard", "command-guard", "path-guard", "commit-test-gate", "commit-typecheck-gate", "lockfile-guard", "secret-file-guard", "lint-on-save"],
+    strict: ["branch-guard", "command-guard", "path-guard", "commit-test-gate", "commit-typecheck-gate", "lockfile-guard", "secret-file-guard", "lint-on-save", "tdd-guard"],
+};
+const RULES = {
+    workflow: (preset) => ({
+        id: "preset-workflow",
+        title: "Development Workflow",
+        priority: 10,
+        content: preset === "strict"
+            ? [
+                "## TDD Development Rules",
+                "- Always write or update tests before changing source code.",
+                "- Confirm tests fail for the expected reason before implementing the minimum code change.",
+                "- Every source file must have a corresponding test file.",
+                "- Do not modify source code without test coverage for the behavior being changed.",
+            ].join("\n")
+            : [
+                "## Testing Rules",
+                "- Run the test suite before every commit; a red suite is never committed.",
+                "- Add or update tests alongside any behavior change.",
+            ].join("\n"),
+    }),
+    branching: {
+        id: "preset-branching",
+        title: "Branch Workflow",
+        priority: 20,
+        content: [
+            "## Branch Workflow Rules",
+            "- Always work on a dedicated branch; never commit directly on main or master.",
+            "- Never force-push to a shared branch and never bypass git hooks.",
+            "- Commit work in logical task-sized units.",
+        ].join("\n"),
+    },
+    quality: {
+        id: "preset-quality",
+        title: "Quality Gates",
+        priority: 30,
+        content: [
+            "## Quality Rules",
+            "- Lint and type errors must be fixed before completing work.",
+            "- Do not write into build output, dependency directories or lockfiles by hand.",
+            "- Never touch secrets or credential files.",
+        ].join("\n"),
+    },
+};
+export function buildPresetHarness(preset, facts, meta = {}) {
+    const hooks = [];
+    for (const block of HOOKS_BY_PRESET[preset]) {
+        const params = defaultParamsFor(block, facts);
+        if (params === null)
+            continue;
+        hooks.push({ block, params, mode: "block" });
+    }
+    const stacks = (facts?.languages ?? []).map((language, i) => ({
+        name: language,
+        framework: facts?.frameworks?.[i] ?? facts?.frameworks?.[0] ?? "none",
+        language,
+        packageManager: facts?.packageManagers?.[i] ?? facts?.packageManagers?.[0],
+        testRunner: facts?.testCommands?.[0],
+        linter: facts?.lintCommands?.[0],
+    }));
+    const rules = preset === "minimal"
+        ? [RULES.branching, RULES.quality]
+        : [RULES.workflow(preset), RULES.branching, RULES.quality];
+    // Schema defaults (loop, permissions, enforcement) come from the schema itself.
+    return HarnessConfigSchema.parse({
+        version: "1.0",
+        project: { name: meta.name, description: meta.description, stacks },
+        rules,
+        hooks,
+    });
+}

package/dist/generators/hooks.js

@@ -114,10 +114,13 @@ function flush(d,   t) {
 const OMH_CMD_UNWRAP_AWK = String.raw `
 BEGIN { FS = "\t" }
 {
-  i = 1
+  i = 1; envp = ""
   while (i <= NF) {
-    while (i <= NF && $i ~ /^[A-Za-z_][A-Za-z0-9_]*=/) i++
+    # NAME=value words are kept in the output (guards such as no-verify-guard
+    # inspect GIT_CONFIG_*); every argv0 matcher skips them.
+    while (i <= NF && $i ~ /^[A-Za-z_][A-Za-z0-9_]*=/) { envp = envp $i "\t"; i++ }
     if (i > NF) break
+    sub(/.*\//, "", $i)          # /usr/bin/git -> git: argv0 matchers compare basenames
     f = $i
     if (f == "env") {
       i++; while (i <= NF && $i ~ /^-/) { if ($i ~ /^-(u|C|S)$/) i++; i++ }; continue
@@ -137,20 +140,20 @@ BEGIN { FS = "\t" }
     if (f == "sh" || f == "bash" || f == "zsh" || f == "dash" || f == "ksh") {
       j = i + 1
       while (j <= NF && $j ~ /^-/) {
-        if ($j ~ /^-[A-Za-z]*c$/) { if (j + 1 <= NF) { print "S\t" $(j + 1); next }; break }
+        if ($j ~ /^-[A-Za-z]*c$/) { if (j + 1 <= NF) { gsub(/\t/, " ", envp); print "S\t" envp $(j + 1); next }; break }
         j++
       }
       break
     }
     if (f == "eval") {
       out = ""; for (k = i + 1; k <= NF; k++) out = out (k > i + 1 ? " " : "") $k
-      print "S\t" out; next
+      gsub(/\t/, " ", envp); print "S\t" envp out; next
     }
     break
   }
   if (i > NF) next
   out = ""; for (k = i; k <= NF; k++) out = out (k > i ? "\t" : "") $k
-  print "R\t" out
+  print "R\t" envp out
 }`;
 // Working-tree fingerprint for gates that want to skip a re-run when nothing
 // changed since the last pass (#112): HEAD plus the tree hash of a temporary
@@ -169,7 +172,10 @@ const OMH_TREE_FINGERPRINT = `_omh_tree_fingerprint() {
   # Always from the repository root, whatever directory the hook runs in.
   # .omh/state is hook-owned scratch (events.jsonl grows on every hook run) and
   # must never count as a change, whether or not the user gitignored it.
-  tree=$(GIT_INDEX_FILE="$idx" git -C "$root" add -A -- . ':(exclude).omh/state' >/dev/null 2>&1 && GIT_INDEX_FILE="$idx" git -C "$root" write-tree 2>/dev/null) || tree=none
+  # (Naming .omh/state in an exclude pathspec makes git refuse when the path
+  # is gitignored, which every omh project does; so add everything, then drop
+  # it from the temporary index.)
+  tree=$(GIT_INDEX_FILE="$idx" git -C "$root" add -A -- . >/dev/null 2>&1 && { GIT_INDEX_FILE="$idx" git -C "$root" rm -r -q --cached --ignore-unmatch -- .omh/state >/dev/null 2>&1 || true; } && GIT_INDEX_FILE="$idx" git -C "$root" write-tree 2>/dev/null) || tree=none
   rm -f "$idx"
   [ "$tree" = "none" ] && { echo none; return 0; }
   printf '%s:%s\\n' "$head" "$tree"

package/dist/nl/parse-intent.d.ts

@@ -1,6 +1,7 @@
 import type { PresetInfo, CatalogBlockInfo } from "./prompt-templates.js";
 import type { HarnessConfig } from "../core/harness-schema.js";
 import type { ProjectFacts } from "../detector/project-detector.js";
+import { type ProviderConfig } from "./config-store.js";
 export interface ParsedIntent {
     presets: string[];
     confidence: number;
@@ -12,6 +13,8 @@ export type LLMRunner = (prompt: string) => Promise<string>;
 export type ClaudeRunner = LLMRunner;
 /** Creates a runner from the saved provider config (~/.omh/config.json) or falls back to claude CLI */
 export declare function createDefaultRunner(): Promise<LLMRunner>;
+/** CI-friendly fallback: pick an API provider from the usual env vars when nothing is saved. */
+export declare function providerConfigFromEnv(): ProviderConfig | undefined;
 /** Legacy default runner using claude CLI directly */
 export declare const defaultClaudeRunner: LLMRunner;
 export declare function parseNaturalLanguage(description: string, availablePresets: PresetInfo[], runner?: ClaudeRunner): Promise<ParsedIntent>;

package/dist/nl/parse-intent.js

@@ -16,7 +16,7 @@ export async function createDefaultRunner() {
     return (prompt) => cliProvider.run(prompt);
 }
 /** CI-friendly fallback: pick an API provider from the usual env vars when nothing is saved. */
-function providerConfigFromEnv() {
+export function providerConfigFromEnv() {
     const key = (name) => process.env[name]?.trim() || undefined;
     const candidates = [
         ["claude", key("ANTHROPIC_API_KEY")],

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

@@ -0,0 +1,70 @@
+import type { HarnessConfig } from "../core/harness-schema.js";
+import type { BuildingBlock } from "../catalog/types.js";
+import type { ProjectFacts } from "../detector/types.js";
+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 type Decision = "on" | "off" | "undecided";
+export interface ChooserInput {
+    description: string;
+    facts?: ProjectFacts;
+    blocks: Pick<BuildingBlock, "id" | "description">[];
+}
+export interface JevRequest {
+    model: string;
+    state: Record<string, unknown>;
+    questions: Record<string, Record<string, unknown>>;
+}
+export interface ChooserResult {
+    strictness: PresetName;
+    blocks: Map<string, Decision>;
+    /** raw probabilities, for `omh init` to print */
+    probabilities?: Record<string, number>;
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+type NoulAnswer = {
+    type: "noul";
+    noul: number;
+};
+type ChoiceAnswer = {
+    type: "choice";
+    choice: string;
+    confidence: number;
+    probabilities: Record<string, number>;
+};
+type Answer = NoulAnswer | ChoiceAnswer | {
+    type: string;
+    [k: string]: unknown;
+};
+export declare const THRESHOLDS: {
+    on: number;
+    off: number;
+    choiceConfidence: number;
+};
+export declare function buildJevRequest(input: ChooserInput): JevRequest;
+export declare function routeAnswers(answers: Record<string, Answer>): Pick<ChooserResult, "strictness" | "blocks" | "probabilities">;
+export declare function chooseWithJev(input: ChooserInput, opts: {
+    apiKey: string;
+    fetchImpl?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<ChooserResult>;
+export interface AppliedHarness extends HarnessConfig {
+    skipped: {
+        block: string;
+        reason: string;
+    }[];
+}
+/** Start from the preset named by the strictness choice (or `base`) and apply the per-block decisions. */
+export declare function applyChoices(base: HarnessConfig, result: Pick<ChooserResult, "strictness" | "blocks">, facts?: ProjectFacts): AppliedHarness;
+/** 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;
+}): 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;
+export {};

package/dist/nl/typesafe-chooser.js

@@ -0,0 +1,144 @@
+import fs from "node:fs";
+import path from "node:path";
+import { buildPresetHarness, defaultParamsFor } from "../core/presets.js";
+// Jev (TypeSafe's System One model) as the catalog chooser (#129). It never
+// generates text: we send the description plus detector facts as `state` and
+// ask one yes/no ("noul") question per selectable block plus one "choice" for
+// the overall strictness, in a single fan-out call. Answers are calibrated
+// probabilities, so a confidence band decides on / off / leave-as-preset.
+// Rule text and free-form params come from presets and the detector, never
+// from the model. Jev is early access, so this is always optional: no key,
+// no call.
+export const TYPESAFE_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+export const TYPESAFE_MODEL = "jev-latest";
+/** Blocks a project may or may not want. Always-on and loop-internal blocks are never asked. */
+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",
+];
+export const THRESHOLDS = { on: 0.65, off: 0.35, choiceConfidence: 0.5 };
+export function buildJevRequest(input) {
+    const byId = new Map(input.blocks.map((b) => [b.id, b]));
+    const questions = {};
+    for (const id of SELECTABLE_BLOCKS) {
+        const b = byId.get(id);
+        if (!b)
+            continue;
+        questions[`block:${id}`] = {
+            type: "noul",
+            instructions: `Should the '${id}' guardrail be enabled for this project? It ${lowerFirst(b.description)}. ` +
+                "Enable it only if the user's description or the detected project facts call for it, " +
+                "or it is a sensible default that would not get in the user's way. " +
+                "If the user explicitly rejects it, the answer is no.",
+        };
+    }
+    questions.strictness = {
+        type: "choice",
+        instructions: "How strict should the generated guardrails be overall, given the user's description?",
+        criteria: {
+            minimal: "only catastrophic actions are blocked (dangerous shell commands, direct commits to main, writes into build output)",
+            safe: "tests and typecheck must pass before commits, lockfiles and secret files are protected, lint runs on save; the workflow stays smooth",
+            strict: "test-first (TDD) is enforced on every source edit in addition to every quality gate",
+        },
+    };
+    const state = { user_description: input.description };
+    if (input.facts)
+        state.detected_project_facts = compactFacts(input.facts);
+    return { model: TYPESAFE_MODEL, state, questions };
+}
+export function routeAnswers(answers) {
+    const blocks = new Map();
+    const probabilities = {};
+    for (const [key, a] of Object.entries(answers)) {
+        if (!key.startsWith("block:") || a.type !== "noul")
+            continue;
+        const p = a.noul;
+        const id = key.slice("block:".length);
+        // Only ids we asked about, only well-formed probabilities: the response is
+        // external input and must not be able to enable an arbitrary block.
+        if (!SELECTABLE_BLOCKS.includes(id))
+            continue;
+        if (typeof p !== "number" || !Number.isFinite(p) || p < 0 || p > 1)
+            continue;
+        probabilities[id] = p;
+        blocks.set(id, p >= THRESHOLDS.on ? "on" : p <= THRESHOLDS.off ? "off" : "undecided");
+    }
+    let strictness = "safe";
+    const s = answers.strictness;
+    if (s && s.type === "choice" && s.confidence >= THRESHOLDS.choiceConfidence && ["minimal", "safe", "strict"].includes(s.choice)) {
+        strictness = s.choice;
+    }
+    return { strictness, blocks, probabilities };
+}
+export async function chooseWithJev(input, opts) {
+    const request = buildJevRequest(input);
+    const f = opts.fetchImpl ?? fetch;
+    const res = await f(TYPESAFE_ENDPOINT, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify(request),
+        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 { ...routeAnswers(json.answers ?? {}), usage: json.usage };
+}
+/** Start from the preset named by the strictness choice (or `base`) and apply the per-block decisions. */
+export function applyChoices(base, result, facts) {
+    const hooks = base.hooks.map((h) => ({ ...h, params: { ...h.params } }));
+    const skipped = [];
+    for (const [id, decision] of result.blocks) {
+        const idx = hooks.findIndex((h) => h.block === id);
+        if (decision === "off") {
+            if (idx >= 0)
+                hooks.splice(idx, 1);
+        }
+        else if (decision === "on" && idx < 0) {
+            const params = defaultParamsFor(id, facts);
+            if (params === null) {
+                skipped.push({ block: id, reason: `${id} needs a param the project detector could not supply (${requiredParamHint(id)})` });
+                continue;
+            }
+            hooks.push({ block: id, params, mode: "block" });
+        }
+    }
+    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);
+    return applyChoices(base, result, facts);
+}
+/** TYPESAFE_API_KEY from the environment, else from a .env file in the project directory. */
+export function resolveTypesafeApiKey(projectDir, env = process.env) {
+    if (env.TYPESAFE_API_KEY?.trim())
+        return env.TYPESAFE_API_KEY.trim();
+    try {
+        const text = fs.readFileSync(path.join(projectDir, ".env"), "utf-8");
+        const m = text.match(/^\s*(?:export\s+)?TYPESAFE_API_KEY\s*=\s*["']?([^"'\r\n#]+)["']?/m);
+        return m?.[1]?.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function requiredParamHint(id) {
+    return { "commit-test-gate": "testCommand", "commit-typecheck-gate": "typecheckCommand", "lint-on-save": "command",
+        "test-on-save": "testCommand", "format-on-save": "command", "path-guard": "blockedPaths" }[id] ?? "params";
+}
+function lowerFirst(s) {
+    return s ? s[0].toLowerCase() + s.slice(1) : s;
+}
+// Only the facts that inform a selection; large irrelevant state degrades Jev.
+function compactFacts(f) {
+    const out = {};
+    for (const k of ["languages", "frameworks", "packageManagers", "testCommands", "lintCommands", "typecheckCommands", "buildCommands", "blockedPaths"]) {
+        if (f[k]?.length)
+            out[k] = f[k];
+    }
+    return out;
+}

package/package.json

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