harnery 0.3.2 → 0.5.0

package/src/core/hooks/cli.ts

@@ -42,6 +42,7 @@ import {
 } from "./effects/index.ts";
 import { emit } from "./events/emit.ts";
 import type { Harness } from "./events/schema.ts";
+import { canonicalize } from "./guard-path.ts";
 import { detectHarness } from "./harness/detect.ts";
 import {
   extractBashCommand,
@@ -774,7 +775,9 @@ async function runPreToolUseGuard(
   harness: Harness,
 ): Promise<void> {
   const toolName = (data.tool_name as string | undefined) ?? "";
-  const targets = collectGuardTargets(toolName, data).map((p) => canonicalize(coordRoot, p));
+  const targets = collectGuardTargets(toolName, data)
+    .map((p) => canonicalize(coordRoot, p))
+    .filter((p): p is string => p !== null);
   if (targets.length === 0) return;
 
   const agentCoordBin = join(coordRoot, "harnery", "bin", "agent-coord");
@@ -822,13 +825,6 @@ async function runPreToolUseGuard(
 /** Canonicalize a path to monorepo-relative form. Absolute paths under
  * coordRoot get the prefix stripped; relative paths pass through (assumed
  * already canonical). */
-function canonicalize(coordRoot: string, p: string): string {
-  if (!p) return p;
-  if (p.startsWith(`${coordRoot}/`)) return p.slice(coordRoot.length + 1);
-  if (p === coordRoot) return ".";
-  return p;
-}
-
 /** Pull the candidate path(s) out of a write-tool payload. Empty array when
  * the tool isn't a write or no path could be derived. */
 function collectGuardTargets(toolName: string, data: Record<string, unknown>): string[] {

package/src/core/hooks/guard-path.ts

@@ -0,0 +1,34 @@
+/**
+ * Canonicalize a write-tool target path for the claim guard.
+ *
+ * Returns the monorepo-relative path, or `null` when the target lies OUTSIDE the
+ * repo (an absolute path not under coordRoot, e.g. a `/tmp` scratchpad or other
+ * session-temp file).
+ *
+ * The claim system is intentionally repo-scoped: it coordinates monorepo files,
+ * not arbitrary absolute paths, so the guard skips out-of-repo targets. Skipping
+ * them is right on two counts. First, it keeps non-repo paths out of a
+ * heartbeat's `files_touched`. Second, the ordering rule compares raw path
+ * strings, and an absolute `/tmp/…` sorts before every repo-relative path
+ * (`/` = 0x2F < any letter), so without this a scratchpad write would spuriously
+ * "block" a legitimately-held repo file. Returning null keeps such paths out of
+ * the claim system entirely.
+ *
+ * Accepted tradeoff: this also means shared out-of-repo files (a user-level
+ * memory or plans directory) are not coordinated across agents. The alternative,
+ * normalizing every path to one consistent key so those stay coordinated, was
+ * rejected as gold-plating a rare, merge-disciplined race in a deadlock-critical
+ * path. Coordinate shared state by keeping it in the repo, not out of it.
+ *
+ * Relative inputs are assumed already-repo-relative (Codex `apply_patch` emits
+ * cwd-relative paths). The in-repo check requires the `<root>/` separator, so a
+ * sibling dir that merely shares a prefix (`/repo-other` vs `/repo`) is treated
+ * as out-of-repo, not stripped.
+ */
+export function canonicalize(coordRoot: string, p: string): string | null {
+  if (!p) return null;
+  if (p === coordRoot) return ".";
+  if (p.startsWith(`${coordRoot}/`)) return p.slice(coordRoot.length + 1);
+  if (p.startsWith("/")) return null; // absolute + not under coordRoot → out-of-repo
+  return p; // relative → treat as repo-relative
+}

package/src/core/hooks/harness/wiring.ts

@@ -0,0 +1,185 @@
+/**
+ * Read-only harness-hook wiring inspection — the inverse of `harn init`'s
+ * writer (commands/init.ts `wireHooks`). Compares what `init` would wire
+ * (HARNESS_SPECS) against what's actually present in a project's harness
+ * settings file, so `harn doctor` and the SessionStart nudge can tell an agent
+ * when a harnery upgrade changed the hook set but the project hasn't been
+ * re-wired yet.
+ *
+ * The shared types + matcher live here (not in init.ts) so the writer, the
+ * doctor check, and the session-start renderer all agree on what "wired" means
+ * — there's exactly one definition of the `agent-hook <subcommand>` match.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  HARNESS_SPECS,
+  type HarnessId,
+  type HarnessSpec,
+  type HookEntryShape,
+  type HookEvent,
+} from "./events.ts";
+
+/** Claude Code + Codex entry: `{ hooks: [{ type, command }] }`. */
+export interface ClaudeHookGroup {
+  matcher?: string;
+  hooks: { type: string; command: string }[];
+}
+/** Cursor entry: a flat `{ command }`. */
+export interface CursorHookGroup {
+  command: string;
+  type?: string;
+  matcher?: string;
+}
+export type HookGroup = ClaudeHookGroup | CursorHookGroup;
+
+export interface SettingsFile {
+  version?: number;
+  hooks?: Record<string, HookGroup[]>;
+  [k: string]: unknown;
+}
+
+/** Build a hook entry in the harness's shape. */
+export function makeEntry(shape: HookEntryShape, command: string): HookGroup {
+  return shape === "cursor" ? { command } : { hooks: [{ type: "command", command }] };
+}
+
+/** Pull every command string out of a hook entry, regardless of shape. */
+export function groupCommands(group: HookGroup): string[] {
+  if ("command" in group && typeof group.command === "string") return [group.command];
+  if ("hooks" in group && Array.isArray(group.hooks)) {
+    return group.hooks.map((h) => h.command).filter((c): c is string => typeof c === "string");
+  }
+  return [];
+}
+
+/**
+ * Whether a hook command string wires the given agent-hook subcommand. The
+ * trailing space is load-bearing: it keeps `stop` from matching `stop-failure`.
+ */
+export function commandWiresSubcommand(command: string, subcommand: string): boolean {
+  return command.includes(`agent-hook ${subcommand} `);
+}
+
+/** Pull the agent-hook subcommand out of a command string, or null if none. */
+function commandSubcommand(command: string): string | null {
+  const m = command.match(/agent-hook\s+([a-z][a-z-]*)\s/);
+  return m ? m[1]! : null;
+}
+
+export interface WiringDiff {
+  /** Spec events not wired in the settings file. */
+  missing: HookEvent[];
+  /** Spec events already wired. */
+  present: HookEvent[];
+  /**
+   * agent-hook subcommands wired in the file that are NOT in the current spec
+   * (e.g. an event renamed/removed by an upgrade). Additive re-init won't clean
+   * these — they need explicit removal — so they're surfaced separately.
+   */
+  orphans: string[];
+}
+
+/**
+ * Pure diff of one settings object against one harness spec. Read-only inverse
+ * of `wireHooks`; no fs, so it's unit-testable.
+ */
+export function diffWiring(settings: SettingsFile, spec: HarnessSpec): WiringDiff {
+  const missing: HookEvent[] = [];
+  const present: HookEvent[] = [];
+  const hooks = settings.hooks ?? {};
+
+  for (const event of spec.events) {
+    const groups = hooks[event.settingsKey] ?? [];
+    const wired = groups.some((g) =>
+      groupCommands(g).some((c) => commandWiresSubcommand(c, event.subcommand)),
+    );
+    (wired ? present : missing).push(event);
+  }
+
+  const specSubcommands = new Set(spec.events.map((e) => e.subcommand));
+  const orphans = new Set<string>();
+  for (const groups of Object.values(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      for (const c of groupCommands(g)) {
+        const sub = commandSubcommand(c);
+        if (sub && !specSubcommands.has(sub)) orphans.add(sub);
+      }
+    }
+  }
+
+  return { missing, present, orphans: [...orphans].sort() };
+}
+
+export interface HarnessWiringStatus {
+  harness: HarnessId;
+  /** Settings file path, relative to the project root. */
+  settingsFile: string;
+  missing: HookEvent[];
+  orphans: string[];
+}
+
+/**
+ * Inspect every harness whose settings file exists under `projectRoot` and
+ * return only those with *drift*. Read-only; never writes.
+ *
+ * Drift is reported only for a harness the project has **already opted into** —
+ * i.e. at least one harnery hook is already wired. A settings file with zero
+ * harnery hooks just means this harness isn't harnery-wired here (a bare
+ * `.claude/settings.json` is a generic Claude Code file); that's `harn init`'s
+ * job to surface on first run, not drift to nag about every session. A harness
+ * with no settings file at all, or an unparseable one, is skipped.
+ */
+export function loadHarnessWiring(projectRoot: string): HarnessWiringStatus[] {
+  const out: HarnessWiringStatus[] = [];
+  for (const [id, spec] of Object.entries(HARNESS_SPECS) as [HarnessId, HarnessSpec][]) {
+    const settingsPath = resolve(projectRoot, spec.settingsFile);
+    if (!existsSync(settingsPath)) continue;
+    let settings: SettingsFile;
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8")) as SettingsFile;
+    } catch {
+      // Unparseable settings file: can't tell opt-in from noise, and the
+      // harness itself will complain about its own malformed config. Skip.
+      continue;
+    }
+    const diff = diffWiring(settings, spec);
+    if (diff.present.length === 0) continue; // not opted in → not drift
+    if (diff.missing.length === 0 && diff.orphans.length === 0) continue; // current
+    out.push({
+      harness: id,
+      settingsFile: spec.settingsFile,
+      missing: diff.missing,
+      orphans: diff.orphans,
+    });
+  }
+  return out;
+}
+
+/**
+ * Resolve the harnery package version for context in nudges/checks. Walks up
+ * from this module to the package root (works under Bun from `src/` and Node
+ * from `dist/`). Returns "" if unresolved — callers omit it from the message.
+ */
+export function harneryVersion(): string {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i++) {
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        if (pkg.name === "harnery" && typeof pkg.version === "string") return pkg.version;
+      } catch {
+        /* no package.json here, or not ours; keep walking up */
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    /* import.meta.url unavailable or fs error */
+  }
+  return "";
+}

package/src/lib/completion/bash.ts

@@ -162,6 +162,42 @@ function bashEscape(s: string): string {
  * to subcommand / option / value completion. `fn` is the function-name prefix
  * and `binName` is the CLI name used for the `__complete` callback.
  */
+/**
+ * DYNAMIC bash completion: a thin, tree-independent shim. Instead of baking the
+ * command tree into case-tables (which go stale on any command/flag change),
+ * it hands the live command line to `<bin> __complete-line` on every <Tab> and
+ * lets the binary — which always knows its own current tree — answer. Install
+ * once; never regenerate. The trailing `\x1f:<n>` line carries the directive
+ * bitmask (bit 0 = fall back to file completion).
+ */
+export function generateBashDynamic(binName: string): string {
+  const fn = fnPrefix(binName);
+  return `# ${binName} bash completion (dynamic; install once, never stale). Do not edit.
+# Source via:  eval "$(${binName} completion bash --dynamic)"
+${fn}() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local raw line directive=0
+  local -a cands=()
+  raw="$(${binName} __complete-line "$COMP_CWORD" -- "\${COMP_WORDS[@]}" 2>/dev/null)" || return
+  while IFS= read -r line; do
+    [ -z "$line" ] && continue
+    if [ "\${line:0:2}" = $'\\x1f:' ]; then
+      directive="\${line:2}"
+    else
+      cands+=( "\${line%%$'\\t'*}" )
+    fi
+  done <<< "$raw"
+  if (( directive & 1 )); then
+    COMPREPLY=( $(compgen -f -- "$cur") )
+    return
+  fi
+  local IFS=$'\\n'
+  COMPREPLY=( $(compgen -W "\${cands[*]}" -- "$cur") )
+}
+complete -F ${fn} ${binName}
+`;
+}
+
 function bashDriver(fn: string, binName: string): string {
   return `${fn}() {
   local cur prev words cword

package/src/lib/completion/fish.ts

@@ -67,6 +67,28 @@ function valueAction(
   return { flag: "-r", arg: "" };
 }
 
+/**
+ * DYNAMIC fish completion: a thin, tree-independent shim that calls
+ * `<bin> __complete-line` on every <Tab> (see bash.ts generateBashDynamic for
+ * the rationale). Fish renders `value\tdescription` lines natively, so the
+ * helper just strips the trailing `\x1f:<n>` directive line. Note: fish's
+ * declarative `complete -a` cannot switch to file completion from inside the
+ * helper, so the File directive is a no-op here — use static fish completion
+ * (`completion fish`) if you need file fallback on a path-valued positional.
+ */
+export function generateFishDynamic(binName: string): string {
+  const fn = `__${binName.replace(/[^a-zA-Z0-9_]/g, "_")}_complete`;
+  return `# ${binName} fish completion (dynamic; install once, never stale). Do not edit.
+# Source via:  ${binName} completion fish --dynamic | source
+function ${fn}
+  set -l toks (commandline -opc)
+  set -l cur (commandline -ct)
+  ${binName} __complete-line (count $toks) -- $toks $cur 2>/dev/null | string match -rv '^\\x1f:'
+end
+complete -c ${binName} -f -a '(${fn})'
+`;
+}
+
 export function generateFish(root: CommandSpec, binName: string): string {
   const out: string[] = [];
   out.push(

package/src/lib/completion/index.ts

@@ -1,5 +1,14 @@
-export { generateBash } from "./bash.js";
-export { generateFish } from "./fish.js";
+export { generateBash, generateBashDynamic } from "./bash.js";
+export { generateFish, generateFishDynamic } from "./fish.js";
+export {
+  type Candidate,
+  type CompletionProviderRunner,
+  type CompletionResult,
+  DIRECTIVE_PREFIX,
+  Directive,
+  encodeResult,
+  resolveCompletions,
+} from "./resolve.js";
 export {
   type CommandSpec,
   type CompletionContextLookup,
@@ -7,4 +16,4 @@ export {
   type PositionalSpec,
   walkProgram,
 } from "./walk.js";
-export { generateZsh } from "./zsh.js";
+export { generateZsh, generateZshDynamic } from "./zsh.js";

package/src/lib/completion/resolve.ts

@@ -0,0 +1,210 @@
+/**
+ * Runtime completion resolver — the authoritative, in-process answer to
+ * "what should I suggest at this cursor position?".
+ *
+ * The static bash/zsh/fish generators bake the whole command tree into shell
+ * case-tables, which go stale the moment a command/flag is added (the script
+ * must be regenerated + reinstalled). The DYNAMIC completion path instead
+ * installs a thin, tree-independent shim that, on every <Tab>, hands the live
+ * command line back to the binary and calls THIS function. Because the binary
+ * always knows its own current command tree, a dynamic shim never goes stale —
+ * install once, ever.
+ *
+ * This mirrors the path-walking the static bash driver does, but in one place
+ * and in TypeScript, so all three shells share identical behavior. It is
+ * deliberately decoupled from Commander internals via the CommandSpec tree
+ * (walkProgram), exactly like the static generators.
+ */
+
+import type { Command } from "commander";
+import { type CommandSpec, type CompletionContextLookup, walkProgram } from "./walk.js";
+
+/** Bitmask of post-processing hints for the shell shim (Cobra-style). */
+export const Directive = {
+  /** Use the returned candidates as completion values. */
+  Default: 0,
+  /** No candidates apply here — the shell should fall back to file completion. */
+  File: 1,
+} as const;
+
+export interface Candidate {
+  value: string;
+  description?: string;
+}
+
+export interface CompletionResult {
+  candidates: Candidate[];
+  directive: number;
+}
+
+/** Provider runner injected by the host CLI (same contract as `__complete`). */
+export type CompletionProviderRunner = (provider: string, partial: string) => Promise<string[]>;
+
+interface PathTables {
+  subcommandsByPath: Map<string, CommandSpec[]>;
+  /** path → flag (long or short) → spec, for both forms. */
+  optionsByPath: Map<string, CommandSpec["options"]>;
+  positionalsByPath: Map<string, CommandSpec["positionals"]>;
+}
+
+function buildTables(root: CommandSpec): PathTables {
+  const subcommandsByPath = new Map<string, CommandSpec[]>();
+  const optionsByPath = new Map<string, CommandSpec["options"]>();
+  const positionalsByPath = new Map<string, CommandSpec["positionals"]>();
+  const walk = (s: CommandSpec): void => {
+    subcommandsByPath.set(s.path, s.subcommands);
+    optionsByPath.set(s.path, s.options);
+    positionalsByPath.set(s.path, s.positionals);
+    for (const sub of s.subcommands) walk(sub);
+  };
+  walk(root);
+  return { subcommandsByPath, optionsByPath, positionalsByPath };
+}
+
+function optionAt(tables: PathTables, path: string, flag: string) {
+  const opts = tables.optionsByPath.get(path) ?? [];
+  return opts.find((o) => o.long === flag || o.short === flag);
+}
+
+function isKnownSubcommand(tables: PathTables, path: string, name: string): boolean {
+  return (tables.subcommandsByPath.get(path) ?? []).some((c) => c.name === name);
+}
+
+/**
+ * Walk the words before the cursor to determine the current command path,
+ * skipping options and the values they consume (mirrors the static driver).
+ * Returns the resolved command path ("" = root).
+ */
+function resolvePath(tables: PathTables, words: string[], cword: number): string {
+  let path = "";
+  let i = 1; // words[0] is the bin name
+  while (i < cword) {
+    const w = words[i] ?? "";
+    if (w.startsWith("-")) {
+      const opt = optionAt(tables, path, w);
+      if (opt?.takesValue) i += 1; // skip the option's value
+    } else if (isKnownSubcommand(tables, path, w)) {
+      path = path ? `${path} ${w}` : w;
+    }
+    i += 1;
+  }
+  return path;
+}
+
+/** Count positional args consumed at the resolved path (non-option, non-subcommand words). */
+function positionalIndex(tables: PathTables, words: string[], cword: number): number {
+  let seen = "";
+  let after = 0;
+  let j = 1;
+  while (j < cword) {
+    const w = words[j] ?? "";
+    if (w.startsWith("-")) {
+      const opt = optionAt(tables, seen, w);
+      if (opt?.takesValue) j += 1;
+    } else if (isKnownSubcommand(tables, seen, w)) {
+      seen = seen ? `${seen} ${w}` : w;
+    } else {
+      after += 1;
+    }
+    j += 1;
+  }
+  return after;
+}
+
+/** Resolve the value source (enum / dynamic-provider / file) for a value slot. */
+async function valueCandidates(
+  source: { valueChoices?: string[]; dynamicProvider?: string },
+  partial: string,
+  runProvider: CompletionProviderRunner,
+): Promise<CompletionResult> {
+  if (source.dynamicProvider) {
+    try {
+      const values = await runProvider(source.dynamicProvider, partial);
+      return { candidates: values.map((value) => ({ value })), directive: Directive.Default };
+    } catch {
+      return { candidates: [], directive: Directive.File };
+    }
+  }
+  if (source.valueChoices && source.valueChoices.length > 0) {
+    return {
+      candidates: source.valueChoices.map((value) => ({ value })),
+      directive: Directive.Default,
+    };
+  }
+  // A value is expected but we have nothing to suggest → let the shell try files.
+  return { candidates: [], directive: Directive.File };
+}
+
+/**
+ * Compute completion candidates for `words` with the cursor at `cword`.
+ * `words[0]` is the bin name; `words[cword]` is the (possibly empty) token
+ * being completed. The shell shim does the final prefix-filtering against that
+ * token, so this returns the full candidate set for the slot.
+ */
+export async function resolveCompletions(
+  program: Command,
+  words: string[],
+  cword: number,
+  lookup: CompletionContextLookup,
+  runProvider: CompletionProviderRunner,
+): Promise<CompletionResult> {
+  const tables = buildTables(walkProgram(program, lookup));
+  const path = resolvePath(tables, words, cword);
+  const cur = words[cword] ?? "";
+  const prev = cword > 0 ? (words[cword - 1] ?? "") : "";
+
+  // Case 1: previous word is an option that takes a value → complete the value.
+  if (prev.startsWith("-")) {
+    const opt = optionAt(tables, path, prev);
+    if (opt?.takesValue) return valueCandidates(opt, cur, runProvider);
+  }
+
+  // Case 2: completing an option name (cur starts with "-").
+  if (cur.startsWith("-")) {
+    const opts = tables.optionsByPath.get(path) ?? [];
+    const candidates: Candidate[] = [];
+    for (const o of opts) {
+      if (o.long) candidates.push({ value: o.long, description: o.description });
+      if (o.short) candidates.push({ value: o.short, description: o.description });
+    }
+    return { candidates, directive: Directive.Default };
+  }
+
+  // Case 3: subcommands available at this path → suggest them.
+  const subs = tables.subcommandsByPath.get(path) ?? [];
+  if (subs.length > 0) {
+    return {
+      candidates: subs.map((c) => ({ value: c.name, description: c.description })),
+      directive: Directive.Default,
+    };
+  }
+
+  // Case 4: positional value slot.
+  const positionals = tables.positionalsByPath.get(path) ?? [];
+  const idx = positionalIndex(tables, words, cword);
+  const pos =
+    positionals[idx] ??
+    (positionals[positionals.length - 1]?.variadic
+      ? positionals[positionals.length - 1]
+      : undefined);
+  if (pos) return valueCandidates(pos, cur, runProvider);
+
+  // Nothing structured to suggest → file completion.
+  return { candidates: [], directive: Directive.File };
+}
+
+/** Sentinel prefix for the trailing directive line in the wire protocol. */
+export const DIRECTIVE_PREFIX = "\x1f:";
+
+/**
+ * Serialize a result for the shell shim: one `value\tdescription` line per
+ * candidate, then a final `\x1f:<directive>` line. The \x1f (unit separator)
+ * prefix makes the directive line unambiguous against real candidate values.
+ */
+export function encodeResult(result: CompletionResult): string {
+  const lines = result.candidates.map((c) =>
+    c.description ? `${c.value}\t${c.description}` : c.value,
+  );
+  lines.push(`${DIRECTIVE_PREFIX}${result.directive}`);
+  return `${lines.join("\n")}\n`;
+}

package/src/lib/completion/zsh.ts

@@ -142,6 +142,40 @@ function truncate(s: string, n: number): string {
   return s.length > n ? `${s.slice(0, n - 1)}…` : s;
 }
 
+/**
+ * DYNAMIC zsh completion: a thin, tree-independent shim that calls
+ * `<bin> __complete-line` on every <Tab> (see bash.ts generateBashDynamic for
+ * the rationale). Candidate lines are `value\tdescription`; the shim converts
+ * the tab to `:` so `_describe` renders descriptions. The trailing `\x1f:<n>`
+ * line carries the directive (bit 0 = file fallback → `_files`).
+ */
+export function generateZshDynamic(binName: string): string {
+  const fn = fnPrefix(binName);
+  return `#compdef ${binName}
+# ${binName} zsh completion (dynamic; install once, never stale). Do not edit.
+${fn}() {
+  emulate -L zsh
+  local line directive=0
+  local -a raw display
+  raw=( "\${(@f)$(${binName} __complete-line $((CURRENT-1)) -- "\${words[@]}" 2>/dev/null)}" )
+  for line in $raw; do
+    [ -z "$line" ] && continue
+    if [[ "$line" == $'\\x1f:'* ]]; then
+      directive="\${line#$'\\x1f:'}"
+    else
+      display+=( "\${line//$'\\t'/:}" )
+    fi
+  done
+  if (( directive & 1 )); then
+    _files
+    return
+  fi
+  _describe -t values 'completions' display
+}
+compdef ${fn} ${binName}
+`;
+}
+
 /**
  * The driver walks `$words` to determine the current command path, then
  * dispatches to subcommand / option / value completion. `fn` is the

package/src/lib/docs-lint.ts

@@ -246,6 +246,11 @@ function checkNamingConvention(repoName: string, _repoPath: string, files: strin
     const name = basename(rel);
     // Allowlisted names
     if (ROOT_FILE_ALLOWLIST.has(name)) continue;
+    // Leading-underscore files are deliberate templates / meta files
+    // (e.g. _template.md), not content. The underscore is a convention
+    // marking "copy me, don't read me as a real doc", so exempt them
+    // from naming discipline rather than forcing kebab-case.
+    if (name.startsWith("_")) continue;
     // Dated files (audits/issues)
     if (DATED_FILE_PATTERN.test(name)) continue;
     // Changelogs

package/dist/commands/uninstall.d.ts

@@ -1,22 +0,0 @@
-/**
- * `harn uninstall`: reverse what `harn init` wired into a project.
- *
- * `init` makes two kinds of change outside the harnery package:
- *   1. Merges `agent-hook` entries into the harness settings file
- *      (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`, or
- *      Codex `.codex/hooks.json`).
- *   2. Creates the `.harnery/` coord root (runtime state: events, councils,
- *      identities, scratch) and stamps the host bin name into
- *      `.harnery/config.jsonc`.
- *
- * `uninstall` undoes (1) by default: it removes only harnery's hook entries from
- * the settings file, preserving any other hooks the consumer added, and deletes
- * the settings file outright when it's left harnery-only. It does NOT touch the
- * `.harnery/` coord root unless `--purge-state` is passed, because that directory
- * holds session history a consumer may want to keep. Idempotent + `--dry-run`,
- * mirroring `init`.
- */
-import type { Command } from "commander";
-import type { EmitContext } from "../commander.js";
-export declare function registerUninstallCommand(program: Command, emit: EmitContext): void;
-//# sourceMappingURL=uninstall.d.ts.map

package/dist/commands/uninstall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uninstall.d.ts","sourceRoot":"","sources":["../../src/commands/uninstall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAWnD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAoFlF"}