@hydraharness/harness-settings-file 0.1.1-rc.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @hydraharness/harness-settings-file
+
+File-backed settings provider. One YAML or JSON document carries every namespace section; external edits hot-publish through `ctx.settings`, and `update()` re-reads the document under a writer lock before writing back atomically, preserving the user's YAML comments, any section owned by a plugin that is not currently loaded, and any on-disk change this process has not observed yet.
+
+## Config
+
+| Field | Meaning | Default |
+|---|---|---|
+| `path` | Settings document path; extension picks the format (`.yaml`/`.yml`/`.json`) | `settings.yaml` under the harness home |
+| `hydraHome` | Harness home used when `path` is omitted | `$HYDRA_HOME` or `~/.hydra` |
+| `watch` | Watch the document and hot-publish external edits | `true` |
+| `debounceMs` | Watcher write-settle window in milliseconds | `100` |
+
+Defaulting is one explicit `resolveSpec(config)` step; an unsupported extension fails at load.
+
+## Behavior
+
+- **Boot fails loud, reload keeps last-good.** An existing-but-invalid document fails plugin load; once live, an unreadable or unparsable edit warns and keeps the last good sections. A missing document resolves every namespace from defaults and `base`; deleting it publishes the same empty state.
+- **Every write derives from the current file.** Under the writer lock, the provider reads and publishes any unseen document change before checking `expectedRevision`, applying `update`/`mutate` edits, and validating the resolved candidate. Editing a sibling field cannot restore a deleted provider from an old cache. A stale revision rejects without writing; an unversioned `replace` deliberately replaces the complete section. An invalid on-disk document rejects the write instead of being overwritten.
+- **Writes hold a cross-process writer lock.** Reading, validation, rename, and in-memory commit run under a `wx`-created `<file>.lock` sibling with exponential backoff and a 2 s acquisition deadline. A contender times out without removing the existing lock because age cannot distinguish a crashed owner from a paused live writer; orphan recovery is an operator action. Readers never take the lock: the rename commit is atomic, so reloads are always consistent.
+- **Write-back is atomic, owner-only, and symlink-proof.** The render exclusive-creates a random-suffix temp sibling with mode `0600` (`wx` refuses to follow a planted symlink) and renames over the target, cleaning the temp up on failure.
+- **YAML edits are leaf-level diffs.** A write sets only the values that changed and deletes only the keys that were removed, so comments, anchors, and formatting survive on every untouched node and on the key of every changed pair; a changed array (or other non-map value) replaces wholesale, taking comments inside it along. JSON re-serializes without comments.
+- **Reloads and writes share one operation chain.** Watcher refreshes and complete write transactions from every namespace queue run one at a time; a refresh cannot interleave between persistence and the corresponding in-memory commit.
+- **The watcher's ready signal reconciles once.** The initial load races the watcher's own setup, so a change written in between never fires an event; the reconcile at ready closes that startup gap.
+- **The native watcher receives a canonical path.** Before Chokidar opens the target, the provider realpaths its deepest existing ancestor and restores any missing suffix. File access and user-facing diagnostics retain the configured path, while Windows cannot mix an 8.3 alias with long-form event paths inside libuv.
+- **Dispose quiesces in every watch mode.** Teardown marks the provider closed, closes the watcher when present, then waits out every queued or in-flight document operation, so nothing publishes after disposal.
+- **Self-write suppression by content.** The provider caches the last good text; a watcher event whose content equals the cache (its own write included) is a no-op.
+- **Host configuration adapters receive the resolved path.** `ctx.settings.documentPath` is the absolute `resolveSpec()` filename, including a custom YAML/JSON path; `prepareDocument()` preserves an existing file or exclusively creates an absent empty file with owner-only permissions before the Host opens it. The browser receives only an availability flag, never reconstructs `$HYDRA_HOME`, and never submits a filesystem target.
+
+## Model Experience
+
+Indirectly, through consumers of `ctx.settings`: this provider only stores and publishes namespace sections, and each consumer's own surface documents any model effect.
+
+#### KV Cache effect
+
+No direct invalidation; the consuming plugin owns any request-prefix changes.
+
+## Known Limitations and Deferred Work
+
+- **Unversioned edits to the same field stay last-write-wins** — send the descriptor's `expectedRevision` to reject an intervening observed change. Revisions belong to the running registration, not a durable cross-process version; arbitrary editors that do not honor the lock can still race the read-rename interval.
+- **A missed watcher event stays unseen until the next signal** — reads never re-stat the file, so a change the watcher fails to report is only folded in by the next event, the next write, or a restart.
+- **Comment preservation is YAML-only and map-shaped** — JSON documents re-serialize without comments (JSON has none), and comments inside a changed array (or attached inline to a changed scalar value) go with the value they described.
+- **No value indirection** — sections hold literal values; `${env:VAR}`-style references for secrets are a deferred seam-level feature.

package/lib/index.js

@@ -0,0 +1,286 @@
+import { Service } from "@hydraharness/cordis";
+import z from "@hydraharness/schemastery";
+import { watch } from "chokidar";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, extname, join, resolve } from "node:path";
+import { Document, parseDocument } from "yaml";
+import { withFileLock, writeFileAtomic } from "@hydraharness/harness-atomic-write";
+import { canonicalizeWatchPath, resolveHydraHome } from "@hydraharness/harness-home-paths";
+import { SettingsProvider, deepEqualJson } from "@hydraharness/harness-settings";
+//#region lib/types/index.js
+/**
+* File-backed settings provider. One YAML or JSON document under the user's
+* harness home carries every namespace section; external edits hot-publish
+* through the seam, and every write re-reads the document under a
+* cross-process writer lock before patching it as a comment-preserving
+* leaf-level diff.
+* @module @hydraharness/harness-settings-file
+*/
+const FORMATS = {
+	".yaml": "yaml",
+	".yml": "yaml",
+	".json": "json"
+};
+/**
+* Resolve the runtime spec from plugin config: an explicit `path` wins,
+* otherwise the document lives at `<harness home>/settings.yaml`.
+* @param config - raw plugin config.
+* @returns the resolved file location, format, and watch behavior.
+*/
+function resolveSpec(config) {
+	const filename = resolve(config.path ?? join(resolveHydraHome(config.hydraHome), "settings.yaml"));
+	const format = FORMATS[extname(filename)];
+	if (format === void 0) throw new Error(`settings-file: extension "${extname(filename)}" is not supported (use .yaml, .yml, or .json)`);
+	return {
+		filename,
+		format,
+		watch: config.watch ?? true,
+		debounceMs: config.debounceMs ?? 100
+	};
+}
+/** Whether a parsed YAML value is a map for diffing purposes. */
+function isMapLike(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Apply the difference between one node's stored and next value as minimal
+* `setIn`/`deleteIn` edits, recursing through maps, so every untouched node —
+* and the key node of every changed pair — keeps its comments, anchors, and
+* formatting. Non-map values (arrays and scalars) replace wholesale when
+* unequal, taking any comments inside them along.
+*/
+function patchNode(document, path, current, next) {
+	if (isMapLike(current) && isMapLike(next)) {
+		for (const key of Object.keys(current)) if (!(key in next)) document.deleteIn([...path, key]);
+		for (const [key, value] of Object.entries(next)) patchNode(document, [...path, key], current[key], value);
+		return;
+	}
+	if (!deepEqualJson(current, next)) document.setIn([...path], next);
+}
+/** Whether a filesystem error means absence; every non-ENOENT failure must surface. */
+function isENOENT(error) {
+	return error?.code === "ENOENT";
+}
+/** Whether an exclusive file create found an existing document. */
+function isEEXIST(error) {
+	return error?.code === "EEXIST";
+}
+/** File-backed settings provider (`settings.yaml`/`.json`). */
+var FileSettingsProvider = class extends SettingsProvider {
+	config;
+	static Config = z.object({
+		path: z.string(),
+		hydraHome: z.string(),
+		watch: z.boolean().default(true),
+		debounceMs: z.number().min(0).default(100)
+	});
+	spec;
+	/**
+	* Raw text of the last successfully parsed or persisted document;
+	* `undefined` while the file is absent. Watcher events whose content equals
+	* this cache are no-ops, which is also the self-write suppression.
+	*/
+	text;
+	/**
+	* Single exclusive operation chain: watcher reloads and document writes run
+	* one at a time in queue order (settled tail), so a write can never render
+	* from text a concurrent reload is busy replacing, and a reload can never
+	* read a half-committed write.
+	*/
+	operations = Promise.resolve();
+	/** Set at dispose: refuse new watcher events and let in-flight work no-op. */
+	closed = false;
+	/** Opaque read of {@link closed}: control flow cannot narrow it across awaits. */
+	isClosed() {
+		return this.closed;
+	}
+	constructor(ctx, config) {
+		super(ctx);
+		this.config = config;
+		this.spec = resolveSpec(config);
+	}
+	/** The local document is always writable through {@link SettingsProvider.update}. */
+	get writable() {
+		return true;
+	}
+	/** The resolved YAML/JSON document path exposed to local configuration surfaces. */
+	get documentPath() {
+		return this.spec.filename;
+	}
+	/** Materialize an absent owner-only document, then return its resolved path. */
+	prepareDocument() {
+		return this.enqueue(async () => {
+			await mkdir(dirname(this.spec.filename), {
+				recursive: true,
+				mode: 448
+			});
+			await withFileLock(this.spec.filename, async () => {
+				try {
+					await writeFile(this.spec.filename, "", {
+						flag: "wx",
+						mode: 384
+					});
+				} catch (error) {
+					if (isEEXIST(error)) return;
+					throw error;
+				}
+				this.text = "";
+				if (!this.isClosed()) this.publish({});
+			});
+			return this.spec.filename;
+		});
+	}
+	async load() {
+		let text;
+		try {
+			text = await readFile(this.spec.filename, "utf8");
+		} catch (error) {
+			if (!isENOENT(error)) throw error;
+			this.text = void 0;
+			return {};
+		}
+		const doc = this.parse(text);
+		this.text = text;
+		return doc;
+	}
+	withWriteTransaction(operation) {
+		return this.enqueue(async () => {
+			await mkdir(dirname(this.spec.filename), {
+				recursive: true,
+				mode: 448
+			});
+			await withFileLock(this.spec.filename, async () => {
+				await this.reconcileFromDisk();
+				await operation();
+			});
+		});
+	}
+	/** Queue one exclusive document operation behind every earlier one. */
+	enqueue(operation) {
+		const task = this.operations.then(operation);
+		this.operations = task.then(() => void 0, () => void 0);
+		return task;
+	}
+	/** Queue a reload; only an invariant violation escaping a commit can reject it. */
+	queueRefresh() {
+		this.enqueue(() => this.refresh()).catch((error) => {
+			this.ctx.logger.error("settings-file: reload commit failed at %s", this.spec.filename);
+			this.ctx.logger.error(error);
+		});
+	}
+	async persist(ns, section) {
+		const output = this.spec.format === "yaml" ? this.renderYaml(ns, section) : this.renderJson(ns, section);
+		await writeFileAtomic(this.spec.filename, output, {
+			mode: 384,
+			dirMode: 448
+		});
+		this.text = output;
+	}
+	async *[Service.init]() {
+		yield* super[Service.init]();
+		const watcher = this.spec.watch ? watch(await canonicalizeWatchPath(this.spec.filename), {
+			ignoreInitial: true,
+			awaitWriteFinish: {
+				stabilityThreshold: this.spec.debounceMs,
+				pollInterval: Math.max(1, Math.min(this.spec.debounceMs, 10))
+			}
+		}) : void 0;
+		if (watcher !== void 0) {
+			watcher.on("all", () => {
+				if (this.closed) return;
+				this.queueRefresh();
+			});
+			watcher.on("ready", () => {
+				if (this.closed) return;
+				this.queueRefresh();
+			});
+			watcher.on("error", (error) => {
+				this.ctx.logger.warn("settings-file: watcher error on %s", this.spec.filename);
+				this.ctx.logger.warn(error);
+			});
+		}
+		yield async () => {
+			this.closed = true;
+			await watcher?.close();
+			await this.operations;
+		};
+	}
+	/** Parse one document text into raw sections, failing on a non-map root. */
+	parse(text) {
+		let root;
+		if (this.spec.format === "yaml") {
+			const document = parseDocument(text, { prettyErrors: true });
+			if (document.errors.length > 0) throw new Error(`settings-file: invalid document at ${this.spec.filename}: ${document.errors.map((error) => {
+				const at = error.linePos?.[0];
+				/* v8 ignore next -- `prettyErrors` populates linePos on every error; the guard answers its optional type */
+				return `${error.code}${at === void 0 ? "" : ` at line ${String(at.line)}, column ${String(at.col)}`}`;
+			}).join("; ")}`);
+			root = document.toJS() ?? {};
+		} else root = text.trim().length === 0 ? {} : JSON.parse(text);
+		if (typeof root !== "object" || root === null || Array.isArray(root)) throw new TypeError(`settings-file: ${this.spec.filename} must be a map of namespace sections`);
+		return root;
+	}
+	/**
+	* Re-read the document after a watcher event. Unchanged content (including
+	* this provider's own writes) is a no-op; an unreadable or unparsable
+	* document keeps the last good sections and warns — a live hot-reload must
+	* never take the process down. An invariant violation escaping a commit is
+	* not a reload failure and propagates to the queue's error surface.
+	*/
+	async refresh() {
+		if (this.closed) return;
+		try {
+			await this.reconcileFromDisk();
+		} catch (error) {
+			if (error?.code === "INVARIANT") throw error;
+			this.ctx.logger.warn("settings-file: reload failed at %s; keeping the last good document", this.spec.filename);
+			this.ctx.logger.warn(error);
+		}
+	}
+	/**
+	* Compare the on-disk text against the cache and publish any difference
+	* into the seam. Absence publishes the empty document; an unreadable or
+	* unparsable file throws, so each caller picks its policy — a reload warns
+	* and keeps the last good document, a write fails loud.
+	*/
+	async reconcileFromDisk() {
+		let text;
+		try {
+			text = await readFile(this.spec.filename, "utf8");
+		} catch (error) {
+			if (!isENOENT(error)) throw error;
+			text = void 0;
+		}
+		if (text === this.text || this.isClosed()) return;
+		if (text === void 0) {
+			this.text = void 0;
+			this.publish({});
+			return;
+		}
+		const doc = this.parse(text);
+		this.text = text;
+		this.publish(doc);
+	}
+	/**
+	* Render the next YAML text by patching one namespace in the
+	* comment-preserving document. The next section lands as a leaf-level diff
+	* against the stored one — only changed values set, only removed keys
+	* delete — so comments inside the section survive edits to their siblings,
+	* not just comments outside it.
+	*/
+	renderYaml(ns, section) {
+		if (this.text === void 0) return new Document({ [ns]: section }).toString();
+		const document = parseDocument(this.text);
+		const root = document.toJS();
+		patchNode(document, [ns], isMapLike(root) ? root[ns] : void 0, section);
+		return document.toString();
+	}
+	/** Render the next JSON text by replacing one namespace key. */
+	renderJson(ns, section) {
+		const root = this.text === void 0 ? {} : this.parse(this.text);
+		root[ns] = section;
+		return `${JSON.stringify(root, null, 2)}\n`;
+	}
+};
+//#endregion
+export { FileSettingsProvider, FileSettingsProvider as default, resolveSpec };

package/lib/invariant.js

@@ -0,0 +1,24 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@hydraharness/harness-settings-file`.
+* @module @hydraharness/harness-settings-file/invariant
+*/
+const PACKAGE_NAME = "@hydraharness/harness-settings-file";
+/** Cordis companion plugin name. */
+const name = "settings-file-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this provider's contracts are file round-trip,
+* watcher timing, and atomic-write behavior — IO effects proven by package
+* tests; the in-process commit relation is owned by `@hydraharness/harness-settings`.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * File-backed settings provider. One YAML or JSON document under the user's
+ * harness home carries every namespace section; external edits hot-publish
+ * through the seam, and every write re-reads the document under a
+ * cross-process writer lock before patching it as a comment-preserving
+ * leaf-level diff.
+ * @module @hydraharness/harness-settings-file
+ */
+import { Context, Service } from '@hydraharness/cordis';
+import z from '@hydraharness/schemastery';
+import { SettingsProvider, type SettingsNamespace } from '@hydraharness/harness-settings';
+/** Plugin config: file location and hot-reload behavior. */
+export interface Config {
+    /** Settings document path; defaults to `settings.yaml` under the harness home. */
+    path?: string;
+    /** Harness home used when `path` is omitted; defaults to `$HYDRA_HOME` or `~/.hydra`. */
+    hydraHome?: string;
+    /** Watch the document and hot-publish external edits; defaults to true. */
+    watch?: boolean;
+    /** Watcher write-settle window in milliseconds; defaults to 100. */
+    debounceMs?: number;
+}
+/** Document format derived from the configured file extension. */
+type SettingsFormat = 'yaml' | 'json';
+/** Fully resolved provider parameters; defaulting happens here, never inline. */
+interface ResolvedSpec {
+    filename: string;
+    format: SettingsFormat;
+    watch: boolean;
+    debounceMs: number;
+}
+/**
+ * Resolve the runtime spec from plugin config: an explicit `path` wins,
+ * otherwise the document lives at `<harness home>/settings.yaml`.
+ * @param config - raw plugin config.
+ * @returns the resolved file location, format, and watch behavior.
+ */
+export declare function resolveSpec(config: Config): ResolvedSpec;
+/** File-backed settings provider (`settings.yaml`/`.json`). */
+export declare class FileSettingsProvider extends SettingsProvider {
+    config: Config;
+    static Config: z<Config>;
+    private readonly spec;
+    /**
+     * Raw text of the last successfully parsed or persisted document;
+     * `undefined` while the file is absent. Watcher events whose content equals
+     * this cache are no-ops, which is also the self-write suppression.
+     */
+    private text;
+    /**
+     * Single exclusive operation chain: watcher reloads and document writes run
+     * one at a time in queue order (settled tail), so a write can never render
+     * from text a concurrent reload is busy replacing, and a reload can never
+     * read a half-committed write.
+     */
+    private operations;
+    /** Set at dispose: refuse new watcher events and let in-flight work no-op. */
+    private closed;
+    /** Opaque read of {@link closed}: control flow cannot narrow it across awaits. */
+    private isClosed;
+    constructor(ctx: Context, config: Config);
+    /** The local document is always writable through {@link SettingsProvider.update}. */
+    get writable(): boolean;
+    /** The resolved YAML/JSON document path exposed to local configuration surfaces. */
+    get documentPath(): string;
+    /** Materialize an absent owner-only document, then return its resolved path. */
+    prepareDocument(): Promise<string>;
+    protected load(): Promise<Record<string, unknown>>;
+    protected withWriteTransaction(operation: () => Promise<void>): Promise<void>;
+    /** Queue one exclusive document operation behind every earlier one. */
+    private enqueue;
+    /** Queue a reload; only an invariant violation escaping a commit can reject it. */
+    private queueRefresh;
+    protected persist(ns: SettingsNamespace, section: Record<string, unknown>): Promise<void>;
+    [Service.init](): AsyncGenerator<() => Promise<void> | void, void, void>;
+    /** Parse one document text into raw sections, failing on a non-map root. */
+    private parse;
+    /**
+     * Re-read the document after a watcher event. Unchanged content (including
+     * this provider's own writes) is a no-op; an unreadable or unparsable
+     * document keeps the last good sections and warns — a live hot-reload must
+     * never take the process down. An invariant violation escaping a commit is
+     * not a reload failure and propagates to the queue's error surface.
+     */
+    private refresh;
+    /**
+     * Compare the on-disk text against the cache and publish any difference
+     * into the seam. Absence publishes the empty document; an unreadable or
+     * unparsable file throws, so each caller picks its policy — a reload warns
+     * and keeps the last good document, a write fails loud.
+     */
+    private reconcileFromDisk;
+    /**
+     * Render the next YAML text by patching one namespace in the
+     * comment-preserving document. The next section lands as a leaf-level diff
+     * against the stored one — only changed values set, only removed keys
+     * delete — so comments inside the section survive edits to their siblings,
+     * not just comments outside it.
+     */
+    private renderYaml;
+    /** Render the next JSON text by replacing one namespace key. */
+    private renderJson;
+}
+export default FileSettingsProvider;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@hydraharness/harness-settings-file`.
+ * @module @hydraharness/harness-settings-file/invariant
+ */
+import type { Context } from '@hydraharness/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "settings-file-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@hydraharness/harness-settings-file",
+  "description": "File-backed settings provider (settings.yaml) for the Hydra harness",
+  "hydra": {
+    "plugin": {
+      "application": "Persist preferences in settings.yaml and make saved changes available to settings consumers."
+    }
+  },
+  "version": "0.1.1-rc.6",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaiHongPhong1902/Hydra-Harness.git",
+    "directory": "packages/settings/settings-file"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@hydraharness/harness-atomic-write": "^0.1.1-rc.6",
+    "@hydraharness/harness-settings": "^0.1.1-rc.6",
+    "@hydraharness/cordis": "^4.0.2",
+    "@hydraharness/harness-home-paths": "^0.1.1-rc.6",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.6"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.3",
+    "yaml": "^2.9.0",
+    "@hydraharness/schemastery": "^3.18.2"
+  },
+  "devDependencies": {
+    "@hydraharness/harness-atomic-write": "^0.1.1-rc.6",
+    "@hydraharness/harness-invariants": "^0.1.1-rc.6",
+    "@hydraharness/harness-settings": "^0.1.1-rc.6",
+    "@hydraharness/harness-home-paths": "^0.1.1-rc.6",
+    "@hydraharness/cordis": "^4.0.2"
+  }
+}