AI Coding Harness Configuration Library

https://github.com/whit3rabbit/agent-config
Admin
This library installs hooks, MCP servers, prompt rules, skills, and standalone instruction files...
Tokens:29,094
Snippets:417
Trust Score:9.1
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Run the TUI dry-run example

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Execute the bundled TUI example to preview installation plans across supported harnesses without modifying disk state.

```bash
cargo run --example tui_dry_run
```

--------------------------------

### Install and Uninstall Hooks

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Demonstrates the installation, idempotent reinstallation, and uninstallation of hooks.

```rust
use agent_config::hooks::Hooks;
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Install hooks
    Hooks::install(&scope)?;
    println!("Installed hooks.");

    // Idempotent reinstall hooks
    Hooks::install(&scope)?;
    println!("Reinstalled hooks (idempotent).");

    // Uninstall hooks
    Hooks::uninstall(&scope)?;
    println!("Uninstalled hooks.");

    Ok(())
}

```

--------------------------------

### Example Execution Commands

Source: https://github.com/whit3rabbit/agent-config/blob/main/CLAUDE.md

Commands to run end-to-end examples located in the examples/ directory.

```bash
cargo run --example hooks_install_uninstall
cargo run --example mcp_install
cargo run --example dry_run_plan
cargo run --example gen_schema      # regenerates schema/agents.json
```

--------------------------------

### Instruction Install with File References

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Demonstrates installing an instruction using `ReferencedFile`, `InlineBlock`, and `StandaloneFile`.

```rust
use agent_config::instructions::Instruction;
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Assume instruction definition with various file types is prepared.
    // Instruction::install(&scope, "instruction_id", "instruction_version", "path/to/instruction.toml")?;
    println!("Instruction install with ReferencedFile, InlineBlock, and StandaloneFile (example placeholder).");

    Ok(())
}

```

--------------------------------

### Skill Install with Executable Asset

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Shows how to install a skill that includes frontmatter and an executable asset.

```rust
use agent_config::skills::Skill;
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Assume skill definition and executable asset are prepared.
    // Skill::install(&scope, "skill_id", "skill_version", "path/to/skill.toml")?;
    println!("Skill install with frontmatter and executable asset (example placeholder).");

    Ok(())
}

```

--------------------------------

### Install a Skill

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Install a custom skill with a description and body content.

```rust
use agent_config::{skill_by_id, Scope, SkillSpec};

fn main() -> agent_config::Result<()> {
    let spec = SkillSpec::builder("my-skill")
        .owner("myapp")
        .description("Use when my app needs custom repository context.")
        .disable_model_invocation(true)
        .body("# My Skill\n\nFollow the local project conventions.")
        .try_build()?;

    let claude = skill_by_id("claude").expect("claude supports skills");
    claude.install_skill(&Scope::Global, &spec)?;
    Ok(())
}
```

--------------------------------

### Install an MCP Server

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Install an MCP server with environment variables and ownership tracking.

```rust
use agent_config::{mcp_by_id, McpSpec, Scope};

fn main() -> agent_config::Result<()> {
    let spec = McpSpec::builder("github")
        .owner("myapp")
        .stdio("npx", ["-y", "@modelcontextprotocol/server-github"])
        .env_from_host("GITHUB_TOKEN")
        .try_build()?;

    let codex = mcp_by_id("codex").expect("codex supports MCP");
    codex.install_mcp(&Scope::Global, &spec)?;
    Ok(())
}
```

--------------------------------

### MCP Install with Secret Handling

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Demonstrates installing an MCP with `env_from_host` secret handling.

```rust
use agent_config::mcp::Mcp;
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Assume MCP definition and necessary environment variables are set up
    // This is a placeholder for a more complex MCP installation scenario.
    // Mcp::install(&scope, "mcp_id", "mcp_version", "path/to/mcp/definition.toml")?;
    println!("MCP install with env_from_host secret handling (example placeholder).");

    Ok(())
}

```

--------------------------------

### Skill Frontmatter Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/agent.md

Example frontmatter for a SKILL.md file. It includes the skill's name and a description of when to activate it, followed by the skill's goal.

```markdown
---
name: my-skill
description: When to activate this skill.
---

## Goal
...
```

--------------------------------

### Antigravity CLI Command Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/antigravity.md

Illustrates how to reference the Antigravity CLI, which is separate from the desktop app/IDE integration.

```text
antigravitycli
```

--------------------------------

### Install a hook specification

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Build a hook specification and install it into a harness by ID. Use .try_build() instead of .build() in production to avoid panics.

```rust
use agent_config::{by_id, Event, HookSpec, Matcher, Scope};

fn main() -> agent_config::Result<()> {
    let spec = HookSpec::builder("myapp")              // your consumer tag
        .command_program("myapp", ["hook", "claude"])  // what the harness runs
        .matcher(Matcher::Bash)                        // filter to shell calls
        .event(Event::PreToolUse)                      // before each tool call
        .try_build()?;

    let claude = by_id("claude").expect("claude is registered");
    let report = claude.install(&Scope::Global, &spec)?;

    println!("created: {:?}", report.created);
    println!("patched: {:?}", report.patched);
    println!("backed up: {:?}", report.backed_up);
    Ok(())
}
```

--------------------------------

### Install an instruction

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Uses InstructionSpec to define and install a new instruction into a target agent configuration.

```rust
use agent_config::{instruction_by_id, InstructionPlacement, InstructionSpec, Scope};

fn main() -> agent_config::Result<()> {
    let spec = InstructionSpec::builder("MYAPP")
        .owner("myapp")
        .placement(InstructionPlacement::ReferencedFile)
        .body("# MyApp\n\nProject-specific guidance loaded into the agent every session.\n")
        .try_build()?;

    let claude = instruction_by_id("claude").expect("claude instruction-capable");
    let report = claude.install_instruction(&Scope::Global, &spec)?;
    println!("created: {:?}", report.created);
    println!("patched: {:?}", report.patched);
    Ok(())
}
```

--------------------------------

### MCP Servers Configuration Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/agent.md

An example JSON object for configuring MCP servers. This map defines servers by name, specifying their command, arguments, and environment variables.

```json
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["/path/to/server.js"],
      "env": { "API_KEY": "secret" }
    }
  }
}
```

--------------------------------

### SKILL.md Frontmatter Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/claude.md

Illustrates the frontmatter structure for a SKILL.md file, showcasing various configuration options for a skill.

```markdown
---
name: my-skill
description: Clear, specific trigger phrase for skill activation
when_to_use: Use for repository-specific review workflows
argument-hint: issue-id
arguments:
  - issue
disable-model-invocation: true
user-invocable: true
allowed-tools:
  - Read
  - Bash
disallowed-tools:
  - Write
model: inherit
effort: high
context: fork
agent: reviewer
paths:
  - src/**
shell: bash
---

## Goal
Describe what the skill does.

## Instructions
Step-by-step guidance.

## Examples
Usage examples.

## Constraints
Limitations or edge cases.
```

--------------------------------

### MCP Server Configuration Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/claude.md

An example of how to configure MCP servers in Claude Code. This JSON structure defines server details, including command, arguments, and environment variables.

```json
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["/path/to/server.js"],
      "env": {
        "API_KEY": "${API_KEY}"
      }
    }
  }
}
```

--------------------------------

### CodeBuddy Hooks Configuration Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/codebuddy.md

Example JSON structure for configuring CodeBuddy hooks, specifying event types, matchers, and commands.

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "myapp hook codebuddy" }],
        "_agent_config_tag": "myapp"
      }
    ]
  }
}
```

--------------------------------

### Install MCP Servers from JSON Object Map

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Use this function when your harness reads MCP servers from a JSON object map keyed by name. It delegates to `mcp_json_object` for installation.

```rust
fn install_mcp(&self, scope: &Scope, spec: &McpSpec) -> Result<InstallReport, AgentConfigError> {
    spec.validate()?;
    let cfg    = Self::mcp_path(scope)?;
    let ledger = ownership::mcp_ledger_for(&cfg);
    mcp_json_object::install(&cfg, &ledger, spec)
}
```

--------------------------------

### Tabnine Hooks Configuration

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/tabnine.md

Example of configuring Tabnine hooks for the 'BeforeTool' event, specifying a 'Bash' matcher and a 'command' hook.

```json
{
  "hooks": {
    "BeforeTool": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "myapp hook tabnine" }],
        "_agent_config_tag": "myapp"
      }
    ]
  }
}
```

--------------------------------

### OpenCode MCP Server Configuration

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/opencode.md

Example JSON configuration for setting up a local MCP server for OpenCode. This configuration specifies the server type, command to execute, and can be placed in either user or project scope configuration files.

```json
{
  "mcp": {
    "my-server": {
      "type": "local",
      "command": ["node", "/path/to/server.js"]
    }
  }
}
```

--------------------------------

### Cursor MCP Server Configuration

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/cursor.md

Example JSON configuration for setting up an MCP server within Cursor. This allows for custom server integrations. Changes require restarting Cursor.

```json
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["/path/to/server.js"]
    }
  }
}
```

--------------------------------

### Codex MCP Server Configuration

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/codex.md

Example TOML configuration for setting up MCP servers in Codex. Supports stdio and http transports.

```toml
[mcp_servers.my_server]
command = "node"
args = ["/path/to/server.js"]

[mcp_servers.my_server.env]
API_KEY = "${API_KEY}"
```

--------------------------------

### Example Path Helper Function

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Illustrates how to define a path helper function that resolves paths based on the provided scope (Global or Local). This is crucial for managing agent configurations across different environments.

```rust
fn settings_path(scope: &Scope) -> Result<PathBuf, AgentConfigError> {
    Ok(match scope {
        Scope::Global    => paths::claude_home()?.join("settings.json"),
        Scope::Local(p)  => p.join(".claude").join("settings.json"),
    })
}
```

--------------------------------

### Antigravity CLI MCP Server Configuration (Local)

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/antigravitycli.md

Configure local MCP servers for the Antigravity CLI. This example shows a Node.js server for SQLite exploration.

```json
{
  "mcpServers": {
    "sqlite-explorer": {
      "command": "node",
      "args": ["/usr/local/bin/sqlite-mcp-server.js"],
      "env": {
        "SQLITE_DB_PATH": "/var/data/app.db"
      }
    }
  }
}
```

--------------------------------

### Iterate supported harnesses and capabilities

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Iterate through all available integrations or filter by specific capabilities like MCP, skills, or instructions. Always check supported scopes before attempting installation to avoid UnsupportedScope errors.

```rust
use agent_config::{all, instruction_capable, mcp_capable, skill_capable, Scope};

// Guard against `UnsupportedScope` by checking `supported_scopes()` first.
// Calling `install` or `is_installed` on a scope the harness rejects returns
// `AgentConfigError::UnsupportedScope` rather than writing anywhere.
for integration in all() {
    if integration.supported_scopes().contains(&Scope::Global.kind())
        && integration.is_installed(&Scope::Global, "myapp").unwrap_or(false)
    {
        println!("{} has myapp installed", integration.display_name());
    }
}

for mcp in mcp_capable() {
    println!("{} supports MCP", mcp.id());
}

for skills in skill_capable() {
    println!("{} supports skills", skills.id());
}

for instr in instruction_capable() {
    println!("{} supports instructions", instr.id());
}
```

--------------------------------

### JSON Structure for MCP Servers

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Example JSON structure for configuring MCP servers, where the 'mcpServers' key holds an object map of server configurations.

```json
{ "mcpServers": { "my-server": { "command": "node", "args": [...] } } }
```

--------------------------------

### iFlow Hooks Configuration Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/iflow.md

This JSON structure defines how to configure hooks for the iFlow CLI. It specifies event types like 'PreToolUse' and maps them to specific commands or actions, with an optional agent configuration tag.

```json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "myapp hook iflow" }],
        "_agent_config_tag": "myapp"
      }
    ]
  }
}
```

--------------------------------

### Install MCP Servers using TOML Patch

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

This pattern is for harnesses using TOML for MCP server configuration. It involves building a TOML table and using `toml_patch` functions for reading, checking ownership, and upserting.

```rust
toml_patch::read_or_empty(&cfg)
toml_patch::contains_named_table(&doc, &["mcp_servers"], &spec.name)
toml_patch::upsert_named_table(&mut doc, &["mcp_servers"], &spec.name,
  build_mcp_table(spec))
toml_patch::to_string(&doc)
ownership::record_install(&ledger, &spec.name, &spec.owner_tag, hash)
```

--------------------------------

### Antigravity CLI MCP Server Configuration (Remote)

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/antigravitycli.md

Configure remote MCP servers for the Antigravity CLI. This example specifies a server URL and authorization headers.

```json
{
  "mcpServers": {
    "remote-indexer": {
      "serverUrl": "https://example.com/mcp",
      "headers": {
        "Authorization": "Bearer TOKEN"
      }
    }
  }
}
```

--------------------------------

### Markdown Block Upsert Example

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

This markdown snippet shows how an agent configuration block is inserted into a file. The 'BEGIN' and 'END' tags are used to identify and manage the block.

```markdown
<!-- BEGIN AGENT-CONFIG:myapp -->
Use myapp prefix.
<!-- END AGENT-CONFIG:myapp -->
```

--------------------------------

### Preview configuration changes with dry-run plans

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Use planner functions to generate an InstallPlan or UninstallPlan that enumerates potential file system and ledger changes without executing them.

```rust
use agent_config::{by_id, PlanStatus};

let plan = by_id("claude").unwrap().plan_install(&scope, &spec)?;
match plan.status {
    PlanStatus::WillChange => println!("{} change(s) planned", plan.changes.len()),
    PlanStatus::NoOp => println!("nothing to do"),
    PlanStatus::Refused => println!("refused: {:?}", plan.changes),
}
```

--------------------------------

### Uninstall a Hook

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Remove a previously installed hook using the application tag.

```rust
let claude = by_id("claude").unwrap();
let report = claude.uninstall(&Scope::Global, "myapp")?;

if report.not_installed {
    println!("nothing to remove");
} else {
    println!("removed: {:?}", report.removed);
    println!("patched: {:?}", report.patched);
    println!("restored backups: {:?}", report.restored);
}
```

--------------------------------

### Build and Test Commands

Source: https://github.com/whit3rabbit/agent-config/blob/main/CLAUDE.md

Standard Cargo commands for building the library, running tests, and generating documentation or linting.

```bash
cargo build                    # build the library
cargo test                     # run all tests (unit + integration)
cargo test --lib               # unit tests only
cargo test --test registry     # integration tests only
cargo test <test_name>         # run a single test by name
cargo doc --no-deps            # generate rustdoc
cargo clippy --all-targets     # lints lib + tests + examples
```

--------------------------------

### Dry Run Plan Install/Uninstall

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Provides previews of `plan_install` and `plan_uninstall` operations without making any changes.

```rust
use agent_config::plan::{plan_install, plan_uninstall};
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Perform a dry run of installation
    let install_plan = plan_install(&scope, "agent_id", "agent_version")?;
    println!("Dry run install plan: {:?}", install_plan);

    // Perform a dry run of uninstallation
    let uninstall_plan = plan_uninstall(&scope, "agent_id", "agent_version")?;
    println!("Dry run uninstall plan: {:?}", uninstall_plan);

    Ok(())
}

```

--------------------------------

### Contract Enforcement for Install/Uninstall Operations

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

This contract outlines the expected behavior for install and uninstall operations, including idempotency and state checks. It is enforced by integration tests.

```plaintext
install → is_installed=true
install (again) → already_installed=true
uninstall → is_installed=false
uninstall (again) → not_installed=true
plan_install (no-op) → no on-disk changes after the call
```

--------------------------------

### Restoring Backup with State Check

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Shows the specific method `safe_fs::restore_backup_if_matches` used to restore a backup during uninstall. It refuses to restore if the backup content does not match the desired post-uninstall state.

```rust
safe_fs::restore_backup_if_matches(scope, path, desired_bytes)
```

--------------------------------

### Add agent-config dependency

Source: https://github.com/whit3rabbit/agent-config/blob/main/README.md

Add the crate to your Cargo.toml file.

```toml
[dependencies]
agent-config = "0.4"
```

--------------------------------

### Default OpenCode Plugin Hook

Source: https://github.com/whit3rabbit/agent-config/blob/main/docs/agents/opencode.md

This TypeScript plugin is automatically generated by agent-config. It intercepts tool execution before it happens, specifically for 'bash' tools, and logs the tool and its arguments to a custom application endpoint. Re-running the install process will overwrite this file.

```typescript
// Generated by agent-config. Edit at your own risk.
// Re-running install will overwrite this file.

import type { Plugin } from "@opencode-ai/plugin";

export const Hook: Plugin = async ({ $ }) => ({
  "tool.execute.before": async (input, output) => {
    if (input.tool !== "bash") return;
    const payload = JSON.stringify({ tool: input.tool, args: output.args });
    await $`echo ${payload} | myapp hook opencode`;
  },
});
```

--------------------------------

### Implement InlineBlock and StandaloneFile Layout Helpers

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Implement layout helpers for InlineBlock and StandaloneFile placements. These helpers resolve per-scope paths and are used with shim functions in `util::instructions_dir`.

```rust
impl MyAgent {
    fn inline_layout(&self, scope: &Scope)
        -> Result<instructions_dir::InlineLayout, AgentConfigError>
    {
        Ok(instructions_dir::InlineLayout {
            config_dir: Self::instruction_config_dir(scope)?,
            host_file: Self::rules_path(scope)?,
        })
    }
}

impl InstructionSurface for MyAgent {
    fn id(&self) -> &'static str { "myagent" }
    fn supported_instruction_scopes(&self) -> &'static [ScopeKind] {
        &[ScopeKind::Global, ScopeKind::Local]
    }

    fn install_instruction(&self, scope: &Scope, spec: &InstructionSpec)
        -> Result<InstallReport, AgentConfigError>
    {
        instructions_dir::inline_install(scope, self.inline_layout(scope)?, spec)
    }
    // status / plan_install_instruction / plan_uninstall_instruction /
    // uninstall_instruction follow the same one-line delegation pattern.
    // See `src/agents/codex/mod.rs` (InlineBlock) and
    // `src/agents/cline/instructions.rs` (StandaloneFile, with
    // `standalone_layout` and `standalone_*` shims).
}
```

--------------------------------

### Safe File Write with Backup

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Illustrates the pattern for writing to a file with a one-time backup creation on the first patch. This is handled by `safe_fs::write` when the `backup` flag is true.

```rust
safe_fs::write(scope, _, _, true)
```

--------------------------------

### Registering a New Agent

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Add your agent to the main registry and optionally to specific capability lists like MCP, Skill, or Instruction.

```rust
pub fn all() -> Vec<Box<dyn Integration>> {
    vec![
        // ...existing entries...
        Box::new(MyagentAgent::new()),
    ]
}

// Add only if you implemented McpSurface:
pub fn mcp_capable() -> Vec<Box<dyn McpSurface>> { /* same shape */ }

// Add only if you implemented SkillSurface:
pub fn skill_capable() -> Vec<Box<dyn SkillSurface>> { /* same shape */ }

// Add only if you implemented InstructionSurface:
pub fn instruction_capable() -> Vec<Box<dyn InstructionSurface>> { /* same shape */ }

```

--------------------------------

### Discover Capable Agents

Source: https://github.com/whit3rabbit/agent-config/blob/main/examples/README.md

Shows how to iterate through all agents and check for MCP and skill capabilities.

```rust
use agent_config::agent::Agent;
use agent_config::Scope;
use tempfile::tempdir;

fn main() -> anyhow::Result<()> {
    let tmp = tempdir()?;
    let scope = Scope::Local(tmp.path().to_path_buf());

    // Iterate through all agents and check capabilities
    for agent in Agent::all(&scope)? {
        println!("Agent: {:?}", agent.id());
        if agent.mcp_capable() {
            println!("  - MCP Capable");
        }
        if agent.skill_capable() {
            println!("  - Skill Capable");
        }
    }

    Ok(())
}

```

--------------------------------

### Release Verification Commands

Source: https://github.com/whit3rabbit/agent-config/blob/main/CLAUDE.md

Commands to run before creating or moving a release tag to ensure code quality and build integrity.

```bash
cargo test --locked --all-targets
cargo clippy --locked --all-targets -- -D warnings
cargo publish --locked --dry-run
```

--------------------------------

### Cross-Process File Locking Pattern

Source: https://github.com/whit3rabbit/agent-config/blob/main/templates/new-harness/README.md

Illustrates the recommended pattern for wrapping file operations with cross-process locks using `file_lock::with_lock`. The lock guard must be dropped before acquiring a lock on a different file.

```rust
file_lock::with_lock(&path, || { ... })
```
Tokens:
Raw