@uluops/setup 0.4.0 → 0.6.3

package/dist/harnesses/gemini-cli.js

@@ -1,41 +1,67 @@
 /**
- * Gemini CLI Harness Profile (Scaffold)
+ * Gemini CLI Harness Profile
  *
  * Paths and metadata are verified from vendor docs.
  * MCP config uses `mcpServers` key (same shape as Claude Code)
  * but at a different file path (~/.gemini/settings.json).
  *
- * NOT YET TESTED with UluOps agents. McpConfigStrategy throws
- * until integration testing is complete.
- *
- * Note: Gemini CLI cannot have underscores in MCP server names
- * (FQN format mcp_serverName_toolName uses underscore as delimiter).
- * Our names use hyphens — safe.
+ * Gemini CLI requires `trust: true` in MCP server config to
+ * allow automatic tool execution without confirmation prompts.
  */
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { HarnessNotTestedError } from "./types.js";
+import { ULUOPS_SERVERS, } from "./types.js";
+import { readConfig, mergeUluopsMcp, removeUluopsMcp, writeConfig, } from "../lib/config-merger.js";
+import { readSettings, writeSettings, mergeUluopsHook, removeUluopsHook, hasUluopsHook, } from "../lib/settings-merger.js";
 class GeminiMcpConfig {
-    async read() {
-        throw new HarnessNotTestedError("Gemini CLI");
+    async read(path) {
+        return readConfig(path);
+    }
+    merge(config, apiKey) {
+        // Gemini CLI requires trust: true for a smooth experience
+        return mergeUluopsMcp(config, apiKey, true);
+    }
+    remove(config) {
+        return removeUluopsMcp(config);
     }
-    merge() {
-        throw new HarnessNotTestedError("Gemini CLI");
+    async write(path, config) {
+        await writeConfig(path, config);
     }
-    remove() {
-        throw new HarnessNotTestedError("Gemini CLI");
+    check(config) {
+        const servers = config["mcpServers"];
+        if (!servers)
+            return false;
+        return ULUOPS_SERVERS.every((name) => name in servers);
+    }
+}
+class GeminiHooks {
+    static HOOK_TYPE = "AfterTool";
+    static MATCHER = "invoke_agent";
+    async install(settingsPath, hookCommand, dryRun) {
+        if (dryRun)
+            return true;
+        const settings = await readSettings(settingsPath);
+        const merged = mergeUluopsHook(settings, hookCommand, GeminiHooks.HOOK_TYPE, GeminiHooks.MATCHER);
+        await writeSettings(settingsPath, merged);
+        return true;
     }
-    async write() {
-        throw new HarnessNotTestedError("Gemini CLI");
+    async remove(settingsPath, dryRun) {
+        if (dryRun)
+            return;
+        const settings = await readSettings(settingsPath);
+        const cleaned = removeUluopsHook(settings, GeminiHooks.HOOK_TYPE);
+        await writeSettings(settingsPath, cleaned);
     }
-    check() {
-        return false;
+    async check(settingsPath) {
+        const settings = await readSettings(settingsPath);
+        return hasUluopsHook(settings, GeminiHooks.HOOK_TYPE);
     }
 }
 const home = join(homedir(), ".gemini");
 export const geminiCliProfile = {
     name: "gemini-cli",
     displayName: "Gemini CLI",
+    status: "stable",
     homeDir: home,
     agentFormat: "markdown",
     factoryTarget: "gemini-cli",
@@ -46,9 +72,9 @@ export const geminiCliProfile = {
         localMcpConfig: ".gemini/settings.json",
         agentsDir: join(home, "agents"),
         commandsDir: join(home, "commands"),
-        settingsPath: null,
-        toolsDir: null,
+        settingsPath: join(home, "settings.json"),
+        toolsDir: join(home, "tools", "agent-metrics"),
     },
     mcpConfig: new GeminiMcpConfig(),
-    hooks: null,
+    hooks: new GeminiHooks(),
 };

package/dist/harnesses/index.d.ts

@@ -12,7 +12,16 @@ export declare const ALL_PROFILES: readonly HarnessProfile[];
 export declare function resolveHarnessName(input: string): string;
 /** Get a harness profile by name or alias. Throws if not found. */
 export declare function getProfile(name: string): HarnessProfile;
-/** Detect which harnesses are installed by probing home directories. */
+/**
+ * Detect which harnesses are installed by probing home directories.
+ *
+ * Excludes experimental profiles even when their home dir is present:
+ * auto-detection should never return a profile that will throw
+ * HarnessNotTestedError on use. Users can still opt in with
+ * `--harness <name>`, which goes through getProfile() and surfaces the
+ * explicit error message — the relational promise "in the detected
+ * list = safe to install" is preserved.
+ */
 export declare function detectHarnesses(): HarnessProfile[];
 /** List all available harness names (not aliases). */
 export declare function listHarnesses(): string[];

package/dist/harnesses/index.js

@@ -35,9 +35,18 @@ export function getProfile(name) {
     }
     return profile;
 }
-/** Detect which harnesses are installed by probing home directories. */
+/**
+ * Detect which harnesses are installed by probing home directories.
+ *
+ * Excludes experimental profiles even when their home dir is present:
+ * auto-detection should never return a profile that will throw
+ * HarnessNotTestedError on use. Users can still opt in with
+ * `--harness <name>`, which goes through getProfile() and surfaces the
+ * explicit error message — the relational promise "in the detected
+ * list = safe to install" is preserved.
+ */
 export function detectHarnesses() {
-    return ALL_PROFILES.filter((p) => existsSync(p.paths.home));
+    return ALL_PROFILES.filter((p) => p.status === "stable" && existsSync(p.paths.home));
 }
 /** List all available harness names (not aliases). */
 export function listHarnesses() {

package/dist/harnesses/opencode.d.ts

@@ -10,5 +10,5 @@
  *
  * Verified working shape from ~/opencode.jsonc (2026-04-30).
  */
-import type { HarnessProfile } from "./types.js";
+import { type HarnessProfile } from "./types.js";
 export declare const opencodeProfile: HarnessProfile;

package/dist/harnesses/opencode.js

@@ -12,11 +12,10 @@
  */
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, isAbsolute } from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
-import { ConfigParseError } from "./types.js";
+import { ULUOPS_SERVERS, ConfigParseError } from "./types.js";
 import { atomicWrite } from "../lib/atomic-write.js";
-const ULUOPS_SERVERS = ["uluops-tracker", "uluops-registry"];
 class OpenCodeMcpConfig {
     /** Maps requested path → actual resolved path (for .jsonc fallback). */
     resolvedPaths = new Map();
@@ -50,17 +49,17 @@ class OpenCodeMcpConfig {
         const existing = (typeof raw === "object" && raw !== null ? raw : {});
         const tracker = {
             type: "local",
-            command: ["npx", "-y", "uluops-tracker-mcp-client"],
+            command: ["npx", "-y", "@uluops/ops-mcp"],
             enabled: true,
             timeout: 30000,
             environment: {
-                ULUOPS_TRACKER_API_URL: "https://api.uluops.ai/api/v1",
-                ULUOPS_TRACKER_API_KEY: apiKey,
+                ULUOPS_BASE_URL: "https://api.uluops.ai/api/v1",
+                ULUOPS_API_KEY: apiKey,
             },
         };
         const registry = {
             type: "local",
-            command: ["npx", "-y", "uluops-registry-mcp-client"],
+            command: ["npx", "-y", "@uluops/registry-mcp"],
             enabled: true,
             timeout: 30000,
             environment: {
@@ -107,11 +106,21 @@ class OpenCodeMcpConfig {
         return ULUOPS_SERVERS.every((name) => name in mcp);
     }
 }
-const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+const xdgConfig = (() => {
+    const env = process.env["XDG_CONFIG_HOME"];
+    if (env) {
+        if (!isAbsolute(env) || env.includes("..")) {
+            throw new Error(`XDG_CONFIG_HOME must be an absolute path without traversal: ${env}`);
+        }
+        return env;
+    }
+    return join(homedir(), ".config");
+})();
 const home = join(xdgConfig, "opencode");
 export const opencodeProfile = {
     name: "opencode",
     displayName: "OpenCode",
+    status: "stable",
     homeDir: home,
     agentFormat: "markdown",
     factoryTarget: "opencode",

package/dist/harnesses/types.d.ts

@@ -5,12 +5,29 @@
  * Each harness (Claude Code, OpenCode, Codex, Gemini CLI) implements
  * these interfaces to encapsulate its config format, paths, and capabilities.
  */
+/**
+ * Maturity status of a harness profile.
+ *
+ * - `"stable"` — implementation is tested end-to-end and safe to auto-detect.
+ *   detectHarnesses() returns these.
+ * - `"experimental"` — scaffold only; throws HarnessNotTestedError on most
+ *   operations. getProfile() still resolves these (so `--harness <name>`
+ *   surfaces the explicit error), but detectHarnesses() filters them out so
+ *   automatic install never picks an unusable profile.
+ */
+export type HarnessStatus = "stable" | "experimental";
 /** Static definition of a harness — no runtime state. */
 export interface HarnessProfile {
     /** Canonical name (e.g., 'claude-code', 'opencode', 'codex', 'gemini-cli') */
     readonly name: string;
     /** Display name for CLI output (e.g., 'Claude Code', 'OpenCode') */
     readonly displayName: string;
+    /**
+     * Maturity status. Experimental profiles are excluded from auto-detection
+     * but still accept an explicit `--harness` flag so users can opt in to
+     * the not-yet-tested error surface.
+     */
+    readonly status: HarnessStatus;
     /** Home directory for this harness */
     readonly homeDir: string;
     /** Agent definition format */
@@ -76,6 +93,8 @@ export interface HookStrategy {
     /** Check if hook is currently installed. */
     check(settingsPath: string): Promise<boolean>;
 }
+/** MCP server names installed by UluOps setup. Shared across all harnesses. */
+export declare const ULUOPS_SERVERS: readonly ["uluops-tracker", "uluops-registry"];
 /** Thrown when a harness config file cannot be parsed. */
 export declare class ConfigParseError extends Error {
     readonly path: string;

package/dist/harnesses/types.js

@@ -5,6 +5,8 @@
  * Each harness (Claude Code, OpenCode, Codex, Gemini CLI) implements
  * these interfaces to encapsulate its config format, paths, and capabilities.
  */
+/** MCP server names installed by UluOps setup. Shared across all harnesses. */
+export const ULUOPS_SERVERS = ["uluops-tracker", "uluops-registry"];
 /** Thrown when a harness config file cannot be parsed. */
 export class ConfigParseError extends Error {
     path;

package/dist/lib/asset-catalog.js

@@ -48,9 +48,9 @@ async function scanCommandDir(dir) {
 }
 /** Get all agent command entries from assets. */
 export async function getAgentCommands() {
-    return scanCommandDir(join(ASSETS_DIR, "commands", "agents"));
+    return scanCommandDir(join(ASSETS_DIR, "claude-code", "commands", "agents"));
 }
 /** Get all workflow command entries from assets. */
 export async function getWorkflowCommands() {
-    return scanCommandDir(join(ASSETS_DIR, "commands", "workflows"));
+    return scanCommandDir(join(ASSETS_DIR, "claude-code", "commands", "workflows"));
 }

package/dist/lib/config-merger.d.ts

@@ -2,6 +2,7 @@ interface McpServerConfig {
     command: string;
     args: string[];
     env: Record<string, string>;
+    trust?: boolean;
 }
 export interface ClaudeConfig {
     mcpServers?: Record<string, McpServerConfig>;
@@ -20,7 +21,7 @@ export declare function readConfig(path: string): Promise<ClaudeConfig>;
 /**
  * Merge UluOps MCP server entries into a config, preserving all other keys.
  */
-export declare function mergeUluopsMcp(config: ClaudeConfig, apiKey: string): ClaudeConfig;
+export declare function mergeUluopsMcp(config: ClaudeConfig, apiKey: string, trust?: boolean): ClaudeConfig;
 /**
  * Remove UluOps MCP server entries from a config.
  */

package/dist/lib/config-merger.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { atomicWrite } from "./atomic-write.js";
-const MCP_PACKAGES = ["uluops-tracker-mcp-client", "uluops-registry-mcp-client"];
+const MCP_PACKAGES = ["@uluops/ops-mcp", "@uluops/registry-mcp"];
 /** Check whether the UluOps MCP client packages exist on the npm registry. Returns lists of available and missing packages. */
 export async function checkMcpPackageAvailability() {
     const available = [];
@@ -36,32 +36,40 @@ export async function readConfig(path) {
     catch {
         return {}; // File doesn't exist — fresh config
     }
-    return JSON.parse(raw);
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to parse config at ${path} — file contains invalid JSON`);
+    }
 }
 /**
  * Merge UluOps MCP server entries into a config, preserving all other keys.
  */
-export function mergeUluopsMcp(config, apiKey) {
+export function mergeUluopsMcp(config, apiKey, trust = false) {
     const existing = config.mcpServers ?? {};
+    const trustField = trust ? { trust: true } : {};
     return {
         ...config,
         mcpServers: {
             ...existing,
             "uluops-tracker": {
                 command: "npx",
-                args: ["-y", "uluops-tracker-mcp-client"],
+                args: ["-y", "@uluops/ops-mcp"],
                 env: {
-                    ULUOPS_TRACKER_API_URL: "https://api.uluops.ai/api/v1",
-                    ULUOPS_TRACKER_API_KEY: apiKey,
+                    ULUOPS_BASE_URL: "https://api.uluops.ai/api/v1",
+                    ULUOPS_API_KEY: apiKey,
                 },
+                ...trustField,
             },
             "uluops-registry": {
                 command: "npx",
-                args: ["-y", "uluops-registry-mcp-client"],
+                args: ["-y", "@uluops/registry-mcp"],
                 env: {
                     ULUOPS_REGISTRY_URL: "https://api.uluops.ai/api/v1/registry",
                     ULUOPS_API_KEY: apiKey,
                 },
+                ...trustField,
             },
         },
     };

package/dist/lib/file-ops.d.ts

@@ -27,3 +27,8 @@ export declare function syncAssets(opts: {
     removed: number;
     files: string[];
 }>;
+/**
+ * Back up a file to the UluOps backup directory before modifying it.
+ * No-op if the source file doesn't exist.
+ */
+export declare function backupFile(srcPath: string, backupDir: string): Promise<void>;

package/dist/lib/file-ops.js

@@ -1,5 +1,5 @@
-import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile, writeFile, mkdir, unlink, access, copyFile, readdir } from "node:fs/promises";
+import { join, basename } from "node:path";
 import { fileHash } from "./hash.js";
 /**
  * Copy a file if its content has changed (hash comparison). Returns "copied" or "skipped".
@@ -62,7 +62,6 @@ export async function unlinkFiles(dir, files) {
  * Returns list of copied files, skipped count, and removed count (for old manifest entries).
  */
 export async function syncAssets(opts) {
-    const { readdir } = await import("node:fs/promises");
     if (!opts.dryRun) {
         await mkdir(opts.destDir, { recursive: true });
     }
@@ -105,3 +104,19 @@ export async function syncAssets(opts) {
     }
     return { copied, skipped, removed, files: assetFiles };
 }
+/**
+ * Back up a file to the UluOps backup directory before modifying it.
+ * No-op if the source file doesn't exist.
+ */
+export async function backupFile(srcPath, backupDir) {
+    try {
+        await access(srcPath);
+    }
+    catch {
+        return; // Nothing to back up
+    }
+    await mkdir(backupDir, { recursive: true });
+    const filename = basename(srcPath);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    await copyFile(srcPath, join(backupDir, `${filename}.${timestamp}.bak`));
+}

package/dist/lib/hash.d.ts

@@ -1,2 +1,2 @@
-/** Return a truncated SHA-256 hash (12 hex chars) of the given string content. */
+/** Return the full SHA-256 hash (64 hex chars) of the given string content. */
 export declare function fileHash(content: string): string;

package/dist/lib/hash.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-/** Return a truncated SHA-256 hash (12 hex chars) of the given string content. */
+/** Return the full SHA-256 hash (64 hex chars) of the given string content. */
 export function fileHash(content) {
-    return createHash("sha256").update(content).digest("hex").slice(0, 12);
+    return createHash("sha256").update(content).digest("hex");
 }

package/dist/lib/manifest.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Identifier for a single harness installation in the manifest.
+ *
+ * Today this is the profile name (e.g. `"claude-code"`), assuming a
+ * one-to-one mapping between profiles and installations. The day that
+ * assumption breaks — multiple Claude Code installs (project vs global,
+ * NVM versions, parallel beta channels) — this becomes the seam where
+ * fracture surfaces. When that happens, the right migration is to extend
+ * keys to `{profile.name}@{stable-instance-id}` (e.g. a hash of toolsDir)
+ * rather than overwriting silently. The type alias exists so the
+ * assumption is documented in the schema, not the comments.
+ */
+export type HarnessInstanceKey = string;
 /** Per-harness installation state. */
 export interface HarnessManifest {
     installedAt: string;
@@ -9,13 +22,29 @@ export interface HarnessManifest {
     agents: string[];
     commands: string[];
     hooksInstalled: boolean;
+    /**
+     * Version of @uluops/agent-metrics whose dist/ was copied into the harness tree.
+     * Null when hooks are not installed or when the manifest predates this field.
+     * Verify uses this to detect drift between installed and currently-resolvable versions —
+     * the shared version ledger across the setup↔agent-metrics seam.
+     */
+    hooksInstalledVersion?: string | null;
 }
 /** Top-level manifest with per-harness entries. */
 export interface Manifest {
     version: string;
     installedAt: string;
     shellModified: boolean;
-    harnesses: Record<string, HarnessManifest>;
+    harnesses: Record<HarnessInstanceKey, HarnessManifest>;
+    /**
+     * Tracks whether `@uluops/cli` was installed globally by this setup run.
+     * Null/false when not installed by setup (user-installed or never installed).
+     * Uninstall only removes the global package when this is true — we don't
+     * remove what we didn't install.
+     */
+    cliInstalled?: boolean;
+    /** Version reported by `ulu --version` at install time, for drift detection. */
+    cliInstalledVersion?: string | null;
     contentHash?: string;
 }
 export interface ManifestValidationResult {

package/dist/lib/manifest.js

@@ -110,13 +110,11 @@ async function pathExists(p) {
     }
 }
 async function findMissingFiles(baseDir, subDir, files) {
-    const missing = [];
-    for (const file of files) {
-        if (!(await pathExists(join(baseDir, subDir, file)))) {
-            missing.push(file);
-        }
-    }
-    return missing;
+    const results = await Promise.all(files.map(async (file) => ({
+        file,
+        exists: await pathExists(join(baseDir, subDir, file)),
+    })));
+    return results.filter((r) => !r.exists).map((r) => r.file);
 }
 async function readManifestFile(path) {
     try {

package/dist/lib/paths.d.ts

@@ -17,7 +17,22 @@ export declare function getUluopsDir(): string;
 export declare function getManifestPath(): string;
 /** Return the legacy manifest path for migration. */
 export declare function getLegacyManifestPath(): string;
-/** Return the backup directory for a harness's config files. */
+/**
+ * Return the backup directory for a harness's **config** files.
+ *
+ * Scope is deliberately narrow: this directory holds copies of mutable
+ * user-owned config surfaces (the MCP config file, the shell profile),
+ * NOT vendor-owned tool files in `~/.claude/tools/agent-metrics/`. Tool
+ * files are treated as disposable — they can be regenerated by re-running
+ * setup, and the source of truth lives in the npm-installed
+ * `@uluops/agent-metrics` package. Backing them up would require a
+ * different ritual (versioned snapshots tied to the manifest's
+ * hooksInstalledVersion) and is not provided here.
+ *
+ * Renaming this to `getConfigBackupDir` would be more honest but is a
+ * public surface change deferred until we have a tool-file backup to
+ * disambiguate against.
+ */
 export declare function getBackupDir(harnessName: string): string;
 /** Detect the user's shell and return its name and profile path, or null if unsupported. */
 export declare function getShellProfile(): {

package/dist/lib/paths.js

@@ -54,15 +54,28 @@ async function isProjectMarker(dir) {
     }
     return false;
 }
+/** Validate an env-var-supplied path: must be absolute and contain no traversal sequences. */
+function validateEnvPath(value, varName) {
+    if (!isAbsolute(value)) {
+        throw new Error(`${varName} must be an absolute path, got: ${value}`);
+    }
+    if (value.includes("..")) {
+        throw new Error(`${varName} must not contain traversal sequences: ${value}`);
+    }
+    return value;
+}
 /** Return the Claude config home directory (~/.claude by default, or CLAUDE_HOME env override). */
 export function getClaudeHome() {
-    return process.env["CLAUDE_HOME"] ?? join(homedir(), ".claude");
+    const envHome = process.env["CLAUDE_HOME"];
+    if (envHome)
+        return validateEnvPath(envHome, "CLAUDE_HOME");
+    return join(homedir(), ".claude");
 }
 /** Return the path to Claude's global config file (~/.claude.json by default, or CLAUDE_JSON_PATH env override). */
 export function getClaudeJsonPath() {
     const envPath = process.env["CLAUDE_JSON_PATH"];
     if (envPath)
-        return envPath;
+        return validateEnvPath(envPath, "CLAUDE_JSON_PATH");
     return join(homedir(), ".claude.json");
 }
 /** Return the path to the project-local MCP config file (.mcp.json in project root). */
@@ -81,7 +94,22 @@ export function getManifestPath() {
 export function getLegacyManifestPath() {
     return join(getClaudeHome(), "uluops-manifest.json");
 }
-/** Return the backup directory for a harness's config files. */
+/**
+ * Return the backup directory for a harness's **config** files.
+ *
+ * Scope is deliberately narrow: this directory holds copies of mutable
+ * user-owned config surfaces (the MCP config file, the shell profile),
+ * NOT vendor-owned tool files in `~/.claude/tools/agent-metrics/`. Tool
+ * files are treated as disposable — they can be regenerated by re-running
+ * setup, and the source of truth lives in the npm-installed
+ * `@uluops/agent-metrics` package. Backing them up would require a
+ * different ritual (versioned snapshots tied to the manifest's
+ * hooksInstalledVersion) and is not provided here.
+ *
+ * Renaming this to `getConfigBackupDir` would be more honest but is a
+ * public surface change deferred until we have a tool-file backup to
+ * disambiguate against.
+ */
 export function getBackupDir(harnessName) {
     return join(getUluopsDir(), "backups", harnessName);
 }

package/dist/lib/settings-merger.d.ts

@@ -13,39 +13,54 @@ interface HookMatcher {
     matcher?: string;
     hooks: HookEntry[];
 }
-export interface ClaudeSettings {
+export interface HarnessSettings {
     permissions?: Record<string, unknown>;
     hooks?: Record<string, HookMatcher[]>;
     [key: string]: unknown;
 }
+/**
+ * Supported hook event types in Claude Code's settings.json schema.
+ *
+ * This set is a snapshot of the harness's vocabulary. When Claude Code
+ * adds, renames, or removes hook types, this set rots — the `probeHookSupport`
+ * warning will fire on legitimate user configs and (worse) train users to
+ * ignore it. The snapshot test in `settings-merger.test.ts` exists to make
+ * any change to the set visible in PR review so the warning logic can be
+ * re-evaluated.
+ *
+ * Exported for that test only — runtime callers should use `probeHookSupport`.
+ */
+export declare const CLAUDE_HOOK_TYPES: Set<string>;
+/** Default Claude Code hook event used when no override is configured. */
+export declare const DEFAULT_CLAUDE_HOOK_TYPE = "SubagentStop";
 export interface HookProbeResult {
     hookType: string;
     supported: boolean;
     warning?: string;
 }
 /** Check whether the configured hook event type is in the known supported set. Returns the resolved hook type and a warning if unsupported. */
-export declare function probeHookSupport(): HookProbeResult;
+export declare function probeHookSupport(hookTypeOverride?: string): HookProbeResult;
 /**
  * Read an existing settings.json, or return empty object if it doesn't exist.
  * Throws on malformed JSON to prevent silent data loss during merge+write.
  */
-export declare function readSettings(path: string): Promise<ClaudeSettings>;
+export declare function readSettings(path: string): Promise<HarnessSettings>;
 /**
  * Write settings back to file with stable formatting.
  */
-export declare function writeSettings(path: string, settings: ClaudeSettings): Promise<void>;
+export declare function writeSettings(path: string, settings: HarnessSettings): Promise<void>;
 /**
- * Merge the UluOps SubagentStop hook into settings, preserving all other
+ * Merge the UluOps hook into settings, preserving all other
  * hooks and settings. If a UluOps hook already exists, it is replaced.
  */
-export declare function mergeUluopsHook(settings: ClaudeSettings, hookCommand: string): ClaudeSettings;
+export declare function mergeUluopsHook(settings: HarnessSettings, hookCommand: string, hookTypeOverride?: string, matcher?: string): HarnessSettings;
 /**
- * Remove UluOps hook entries from settings. If SubagentStop becomes empty,
+ * Remove UluOps hook entries from settings. If a hook type becomes empty,
  * the key is removed. If hooks becomes empty, the key is removed.
  */
-export declare function removeUluopsHook(settings: ClaudeSettings): ClaudeSettings;
+export declare function removeUluopsHook(settings: HarnessSettings, hookTypeOverride?: string): HarnessSettings;
 /**
  * Check if a UluOps hook is configured in settings.
  */
-export declare function hasUluopsHook(settings: ClaudeSettings): boolean;
+export declare function hasUluopsHook(settings: HarnessSettings, hookTypeOverride?: string): boolean;
 export {};