harnery 0.0.1 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Kelly
+
+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

@@ -1,3 +1,85 @@
-# harnery
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="assets/harnery-logo-reversed-transparent.svg">
+    <img src="assets/harnery-logo-transparent.svg" alt="Harnery" width="300">
+  </picture>
+</p>
 
-Coming soon — https://harnery.com
+# Harnery
+
+> Multi-agent coordination + harness adapters + portable CLI utilities for Claude Code / Cursor / Codex.
+
+[![CI](https://github.com/ryanjkelly/harnery/actions/workflows/ci.yml/badge.svg)](https://github.com/ryanjkelly/harnery/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/harnery.svg)](https://www.npmjs.com/package/harnery)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+> ⚠️ **Pre-1.0.** API surface is still settling. Pin a specific minor version (`harnery@^0.1.0`) and read the [CHANGELOG](CHANGELOG.md) before each upgrade.
+
+## What it is
+
+`harnery` is a utility layer extracted from years of building agent tooling across a multi-project monorepo. It bundles:
+
+- **Multi-agent coordination:** per-agent heartbeats in `.harnery/active/`, claim-time and commit-time guards, the canonical event stream, harness adapters for Claude Code / Cursor / Codex.
+- **Portable CLI utilities:** `tokens`, `eml`, `env`, `grep`, `docs`, `repo`, `wip`, `share`, `browse`, `fetch`, `read`, and more. Cross-platform and dependency-light, with sensible defaults out of the box.
+- **Standalone web UI:** `harn web up` boots a local Next.js dashboard for the coord layer, councils, and per-project state. Ships with the git clone, not the npm package (see [Install](#install)).
+- **Backup + sync:** `harn backup` snapshots `.harnery/` via [restic](https://restic.net/); `harn sync` keeps a curated subset live across machines via [rclone](https://rclone.org/) (Google Drive or any rclone remote).
+
+## Install
+
+```bash
+npm install -g harnery
+```
+
+Or as a per-project dep:
+
+```bash
+npm install harnery
+```
+
+Then:
+
+```bash
+harn --help
+harn doctor   # one-time runtime + dep check
+```
+
+> **npm gives you the engine + CLI.** The `web/` dashboard and the `docs/` site live in the git repo, not the npm package (which is the CLI + coord engine: `bin`, `dist`, `src`, `schemas`). To run the dashboard, `git clone` the repo, `bun install`, and `harn web up` from there, pointing it at your project with `--coord-root <dir>` (or just run it from inside the project). `harn web up` prints these exact steps if you invoke it without the clone present.
+
+## Use as a CLI library
+
+Project-specific CLIs compose Harnery's command tree and add their own commands on top:
+
+```ts
+// mycli/src/program.ts
+import { createHarneryProgram } from 'harnery/commander';
+import { deployCommand, dbCommand } from './commands';
+
+const program = createHarneryProgram({
+  binName: 'mycli',
+  context: { projectName: 'my-monorepo' },
+});
+
+program.addCommand(deployCommand);
+program.addCommand(dbCommand);
+
+await program.parseAsync(process.argv);
+```
+
+`mycli agents status` then resolves to **the same code** as `harn agents status`, loaded as a library. See [examples/extending-with-commander.ts](examples/extending-with-commander.ts) for the full pattern.
+
+## Documentation
+
+Full docs at **[harnery.com](https://harnery.com)**:
+
+- [Getting started](https://harnery.com/getting-started/install)
+- [CLI reference](https://harnery.com/cli/)
+- [Concepts](https://harnery.com/concepts/coord-layer)
+- [Configuration schema](https://harnery.com/reference/config-schema)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Bug reports and feature requests via [GitHub Issues](https://github.com/ryanjkelly/harnery/issues).
+
+## License
+
+[MIT](LICENSE) © Ryan Kelly

package/bin/agent-coord

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# Wrapper for agent-coord. Runs TypeScript directly via Bun.
+#
+# The canonical event-stream stamps `source: "agent-coord"`; consumers
+# (hooks, CLI spawners) treat the path `harnery/bin/agent-coord` as an
+# opaque address. Sibling launcher is `harnery/bin/harn` for the main
+# harn CLI.
+SCRIPT_PATH="${BASH_SOURCE[0]:-$0}"
+while [ -L "$SCRIPT_PATH" ]; do
+    SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+    LINK_TARGET="$(readlink "$SCRIPT_PATH")"
+    case "$LINK_TARGET" in
+        /*) SCRIPT_PATH="$LINK_TARGET" ;;
+        *) SCRIPT_PATH="$SCRIPT_DIR/$LINK_TARGET" ;;
+    esac
+done
+MODULE_DIR="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+
+# Find bun in common install locations if not already on PATH. Hooks fire
+# under bash subshells whose PATH may differ from the interactive shell.
+if ! command -v bun >/dev/null 2>&1; then
+    for candidate in \
+        "$HOME/.bun/bin/bun" \
+        "/usr/local/bin/bun" \
+        "/opt/homebrew/bin/bun"; do
+        if [ -x "$candidate" ]; then
+            export PATH="$(dirname "$candidate"):$PATH"
+            break
+        fi
+    done
+fi
+
+# Bun-first (zero-build TS); Node-with-dist/ fallback. The published package
+# ships dist/, so this works on a Node-only host with no Bun installed.
+if command -v bun >/dev/null 2>&1; then
+    exec bun run "$MODULE_DIR/src/core/agents/cli.ts" "$@"
+elif [ -f "$MODULE_DIR/dist/core/agents/cli.js" ]; then
+    exec node "$MODULE_DIR/dist/core/agents/cli.js" "$@"
+else
+    echo "agent-coord: needs Bun or a built dist/. Install Bun (https://bun.sh), or build: npm install && npm run build." >&2
+    exit 1
+fi

package/bin/agent-hook

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Wrapper for agent-hook. Runs TypeScript directly via Bun.
+#
+# Lives in harnery/ as of commit 4 of the harnery v0.1 strangler-fig. The
+# binary name stays `agent-hook` because every harness's hooks.json /
+# settings.json line spawns by that bare name + path. Sibling launchers
+# are `harnery/bin/harn` (main CLI) + `harnery/bin/agent-coord` (coord
+# state).
+SCRIPT_PATH="${BASH_SOURCE[0]:-$0}"
+while [ -L "$SCRIPT_PATH" ]; do
+    SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+    LINK_TARGET="$(readlink "$SCRIPT_PATH")"
+    case "$LINK_TARGET" in
+        /*) SCRIPT_PATH="$LINK_TARGET" ;;
+        *) SCRIPT_PATH="$SCRIPT_DIR/$LINK_TARGET" ;;
+    esac
+done
+MODULE_DIR="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+
+# Find bun in common install locations if not already on PATH. Hooks fire
+# under bash subshells whose PATH may differ from the interactive shell.
+if ! command -v bun >/dev/null 2>&1; then
+    for candidate in \
+        "$HOME/.bun/bin/bun" \
+        "/usr/local/bin/bun" \
+        "/opt/homebrew/bin/bun"; do
+        if [ -x "$candidate" ]; then
+            export PATH="$(dirname "$candidate"):$PATH"
+            break
+        fi
+    done
+fi
+
+# Bun-first (zero-build TS); Node-with-dist/ fallback. The published package
+# ships dist/, so harness hooks that spawn `agent-hook` work on a Node-only
+# host with no Bun installed.
+if command -v bun >/dev/null 2>&1; then
+    exec bun run "$MODULE_DIR/src/core/hooks/cli.ts" "$@"
+elif [ -f "$MODULE_DIR/dist/core/hooks/cli.js" ]; then
+    exec node "$MODULE_DIR/dist/core/hooks/cli.js" "$@"
+else
+    echo "agent-hook: needs Bun or a built dist/. Install Bun (https://bun.sh), or build: npm install && npm run build." >&2
+    exit 1
+fi

package/bin/harn

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+# Wrapper for the harn CLI. Prefers Bun for daily dev (zero-build TS execution);
+# falls back to Node if the package was built to dist/ and Bun is unavailable.
+
+SCRIPT_PATH="${BASH_SOURCE[0]:-$0}"
+while [ -L "$SCRIPT_PATH" ]; do
+    SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+    LINK_TARGET="$(readlink "$SCRIPT_PATH")"
+    case "$LINK_TARGET" in
+        /*) SCRIPT_PATH="$LINK_TARGET" ;;
+        *) SCRIPT_PATH="$SCRIPT_DIR/$LINK_TARGET" ;;
+    esac
+done
+MODULE_DIR="$(cd "$(dirname "$SCRIPT_PATH")/.." && pwd)"
+
+# Locate bun in common install paths if not already on PATH. Hook invocations
+# under bash subshells may have a different PATH than the interactive shell.
+if ! command -v bun >/dev/null 2>&1; then
+    for candidate in \
+        "$HOME/.bun/bin/bun" \
+        "/usr/local/bin/bun" \
+        "/opt/homebrew/bin/bun"; do
+        if [ -x "$candidate" ]; then
+            export PATH="$(dirname "$candidate"):$PATH"
+            break
+        fi
+    done
+fi
+
+# Bun-first (zero-build TS); Node-with-dist/ fallback when Bun isn't available.
+# The published npm package ships dist/ (built by prepublishOnly), so the Node
+# branch works out of the box. A bare git clone has neither until you build.
+if command -v bun >/dev/null 2>&1; then
+    exec bun run "$MODULE_DIR/src/cli.ts" "$@"
+elif [ -f "$MODULE_DIR/dist/cli.js" ]; then
+    exec node "$MODULE_DIR/dist/cli.js" "$@"
+else
+    echo "harn: needs Bun or a built dist/. Install Bun (https://bun.sh) for zero-build, or build the Node bundle: npm install && npm run build." >&2
+    exit 1
+fi

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `harn` CLI entry point.
+ *
+ * Parses argv, runs the Commander program returned by createHarneryProgram().
+ * Consumer CLIs import createHarneryProgram() from `harnery/commander` and
+ * compose their own commands on top. See examples/extending-with-commander.ts.
+ */
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/cli.js

@@ -0,0 +1,18 @@
+/**
+ * `harn` CLI entry point.
+ *
+ * Parses argv, runs the Commander program returned by createHarneryProgram().
+ * Consumer CLIs import createHarneryProgram() from `harnery/commander` and
+ * compose their own commands on top. See examples/extending-with-commander.ts.
+ */
+import { createHarneryProgram } from "./commander.js";
+async function main() {
+    const program = createHarneryProgram({
+        binName: "harn",
+    });
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/commander.d.ts

@@ -0,0 +1,128 @@
+/**
+ * `createHarneryProgram` is the composition point.
+ *
+ * harn (this package's CLI) calls this with `binName: 'harn'`.
+ * Consumer CLIs call this with their own binName, then `.addCommand()`
+ * their domain-specific subcommands and `parseAsync()`.
+ *
+ * The returned Commander program is harnery's full command tree. Adding
+ * a command with the same name on the consumer side overrides it, which is
+ * useful for project-specific overlays but uncommon.
+ *
+ * Future commands wire in via `registerXxxCommand(program)` calls below.
+ * Each subdirectory under src/commands/ exports its `register…` function
+ * (Commander pattern).
+ */
+import { Command } from "commander";
+export interface HarneryContextOpts {
+    /**
+     * The binary name shown in --help output. Defaults to "harn". Consumer
+     * CLIs pass their own, e.g. `binName: "mycli"`.
+     */
+    binName?: string;
+    /**
+     * Project-scoped context. Commands that touch state (.harnery/agents/,
+     * .harnery/config.jsonc) consult this to resolve paths + project identity.
+     * Optional: harn standalone runs without it.
+     */
+    context?: HarneryProgramContext;
+    /**
+     * Adapter that lets consumers route structured emissions into their own
+     * OutputContext (e.g. an AsyncLocalStorage-bound writer). When omitted,
+     * harn standalone falls back to a default JSON-to-stdout emitter (see
+     * `defaultEmit` below).
+     */
+    emit?: EmitContext;
+    /**
+     * Top-level command names harnery should NOT register. Use when a
+     * consumer wants to replace harnery's implementation with its own
+     * (Commander throws on duplicate registration). Example: the host CLI has
+     * a project-specific `harn web` (docker stack shim) and passes
+     * `skipCommands: ["web"]` so harnery's generic `web` doesn't collide.
+     */
+    skipCommands?: readonly string[];
+}
+export interface HarneryProgramContext {
+    /** Project name (e.g., "my-monorepo"). Used in user-facing log lines + telemetry tags. */
+    projectName?: string;
+    /** Override the monorepo-root resolver. Default: walk up looking for `.harnery/`. */
+    resolveCoordRoot?: () => string | null;
+    /**
+     * Absolute path to the monorepo root. Commands like `env` use this as the
+     * default `cwd` for `git` invocations. When omitted, commands fall back to
+     * `process.cwd()`.
+     */
+    repoRoot?: string;
+    /**
+     * Submodule directory names relative to `repoRoot`. Consumed by `env` to
+     * report N/M initialized. When omitted, the `env` command skips the
+     * submodule row.
+     */
+    submodules?: readonly string[];
+    /**
+     * Optional callback that returns extra HTTP headers to attach to outbound
+     * `fetch` calls based on the target URL. Useful for consumers that need
+     * to inject auth or bypass headers on certain hostnames (e.g. private
+     * zones behind a WAF). harn standalone skips the callback entirely.
+     */
+    extraHeaders?: (url: string) => Record<string, string>;
+    /**
+     * Shell-completion provider-key lookup. Consumers wire this to a function
+     * mapping (commandPath, option/positional) to a provider key, so that
+     * `--workspace` / `--env` etc. tab-complete dynamically against
+     * consumer-specific data sources. harn standalone falls back to no-op
+     * (static completion only).
+     */
+    completionLookup?: (key: {
+        commandPath: string;
+        option?: string;
+        positional?: number;
+    }) => string | undefined;
+    /**
+     * Shell-completion provider runner. Invoked by the hidden `__complete`
+     * subcommand at tab-time to produce the actual list of completions for
+     * a given provider key.
+     */
+    completionRunner?: (key: string, partial: string) => Promise<string[]>;
+    /**
+     * Extra path prefixes that should be excluded from `harn docs lint`
+     * convention checks (auto-generated API reference dumps, vendored
+     * content directories, etc.). Combined with harnery's built-in
+     * exclusions (`.claude/`, `.harnery/`, `.codex/`, `.cursor/`).
+     */
+    extraDocsExcludedPrefixes?: readonly string[];
+    /**
+     * Default Host header for `tunnel up` when `--vhost` is omitted: a literal
+     * host, or a resolver evaluated at start time (e.g. read a dev stack's
+     * configured hostname so the tunnel lands on the right vhost). When unset, or
+     * the resolver returns null, the tunnel falls back to harnery's built-in
+     * default (`localhost`).
+     */
+    tunnelDefaultVhost?: string | (() => string | null | undefined);
+}
+/**
+ * Minimum emission surface harnery commands need to talk to a host CLI's
+ * OutputContext. Intentionally tiny: just the methods commands actually
+ * call. Designed to grow additively: consumers that want richer output
+ * routing implement these methods; everyone else gets `defaultEmit`'s
+ * JSON-to-stdout fallback.
+ */
+export interface EmitContext {
+    config(opts: {
+        format?: string;
+    }): void;
+    data(payload: unknown): void;
+    rows(rows: Record<string, unknown>[]): void;
+    text(s: string): void;
+    file(path: string, summary: Record<string, unknown>): void;
+    error(err: {
+        code: string;
+        message: string;
+        hint?: string;
+    } | Error | unknown): void;
+    log(msg: string, level?: "debug" | "info" | "warn" | "error"): void;
+    setExitCode(n: number): void;
+}
+export declare const defaultEmit: EmitContext;
+export declare function createHarneryProgram(opts?: HarneryContextOpts): Command;
+//# sourceMappingURL=commander.d.ts.map

package/dist/commander.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commander.d.ts","sourceRoot":"","sources":["../src/commander.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+BpC,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAEhC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC;IAEnB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,gBAAgB,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC/B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvD;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE;QACvB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM,GAAG,SAAS,CAAC;IACzB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACvE;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CACjE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,CAAC,IAAI,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC;IAC5C,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC3D,KAAK,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;IACrF,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IACpE,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,eAAO,MAAM,WAAW,EAAE,WAkCzB,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,kBAAuB,GAAG,OAAO,CA2C3E"}

package/dist/commander.js

@@ -0,0 +1,126 @@
+/**
+ * `createHarneryProgram` is the composition point.
+ *
+ * harn (this package's CLI) calls this with `binName: 'harn'`.
+ * Consumer CLIs call this with their own binName, then `.addCommand()`
+ * their domain-specific subcommands and `parseAsync()`.
+ *
+ * The returned Commander program is harnery's full command tree. Adding
+ * a command with the same name on the consumer side overrides it, which is
+ * useful for project-specific overlays but uncommon.
+ *
+ * Future commands wire in via `registerXxxCommand(program)` calls below.
+ * Each subdirectory under src/commands/ exports its `register…` function
+ * (Commander pattern).
+ */
+import { Command } from "commander";
+import { registerAgentsCommand } from "./commands/agents.js";
+import { registerBackupCommand } from "./commands/backup.js";
+import { registerBrowseCommand } from "./commands/browse.js";
+import { registerBrowseAiCommand } from "./commands/browse-ai.js";
+import { registerCallersCommand } from "./commands/callers.js";
+import { registerCompletionCommand } from "./commands/completion.js";
+import { registerConfigGetCommand } from "./commands/config-get.js";
+import { registerContextCommand } from "./commands/context.js";
+import { registerCookiesCommand } from "./commands/cookies.js";
+import { registerDocsCommand } from "./commands/docs.js";
+import { registerDoctorCommand } from "./commands/doctor.js";
+import { registerEditBatchCommand } from "./commands/edit-batch.js";
+import { registerEmlCommand } from "./commands/eml.js";
+import { registerEnvCommand } from "./commands/env.js";
+import { registerFetchCommand } from "./commands/fetch.js";
+import { registerFileHistoryCommand } from "./commands/file-history.js";
+import { registerGrepCommand } from "./commands/grep.js";
+import { registerInitCommand } from "./commands/init.js";
+import { registerOutlineCommand } from "./commands/outline.js";
+import { registerPresenceCommand } from "./commands/presence.js";
+import { registerReadCommand } from "./commands/read.js";
+import { registerScratchCommand } from "./commands/scratch.js";
+import { registerSessionCommand } from "./commands/session.js";
+import { registerSyncCommand } from "./commands/sync.js";
+import { registerSectionCommand, registerTocCommand } from "./commands/toc.js";
+import { registerTokensCommand } from "./commands/tokens.js";
+import { registerTunnelCommand } from "./commands/tunnel.js";
+import { registerUninstallCommand } from "./commands/uninstall.js";
+import { registerWebCommand } from "./commands/web.js";
+export const defaultEmit = {
+    config() {
+        // No-op for harn standalone: there's only one format (JSON) and it's
+        // already the default. Consumer adapters route this to their own
+        // output-context configurator.
+    },
+    data(payload) {
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+    },
+    rows(rows) {
+        process.stdout.write(`${JSON.stringify(rows)}\n`);
+    },
+    text(s) {
+        process.stdout.write(s.endsWith("\n") ? s : `${s}\n`);
+    },
+    file(path, summary) {
+        process.stdout.write(`${JSON.stringify({ ok: true, file: path, ...summary })}\n`);
+    },
+    error(err) {
+        const payload = err instanceof Error
+            ? { code: err.name || "error", message: err.message }
+            : typeof err === "object" && err !== null
+                ? err
+                : { code: "error", message: String(err) };
+        process.stderr.write(`${JSON.stringify({ error: payload })}\n`);
+        process.exitCode = 1;
+    },
+    log(msg, level = "info") {
+        process.stderr.write(`[${level}] ${msg}\n`);
+    },
+    setExitCode(n) {
+        process.exitCode = n;
+    },
+};
+export function createHarneryProgram(opts = {}) {
+    const program = new Command();
+    const emit = opts.emit ?? defaultEmit;
+    const skip = new Set(opts.skipCommands ?? []);
+    const include = (name) => !skip.has(name);
+    program
+        .name(opts.binName ?? "harn")
+        .description("Multi-agent coordination + harness adapters + portable CLI utilities.")
+        .version(readVersion());
+    registerTokensCommand(program, emit);
+    registerEmlCommand(program, emit);
+    registerEnvCommand(program, emit, opts.context);
+    registerPresenceCommand(program, emit);
+    registerConfigGetCommand(program, emit);
+    registerFileHistoryCommand(program, emit);
+    registerOutlineCommand(program, emit);
+    registerTocCommand(program, emit);
+    registerSectionCommand(program, emit);
+    registerCallersCommand(program, emit, opts.context);
+    registerEditBatchCommand(program, emit);
+    registerGrepCommand(program, emit, opts.context);
+    registerCookiesCommand(program, emit);
+    registerFetchCommand(program, emit, opts.context);
+    registerReadCommand(program, emit);
+    registerBrowseCommand(program, emit, opts.context);
+    registerBrowseAiCommand(program, emit);
+    registerSessionCommand(program, emit);
+    registerCompletionCommand(program, emit, opts.context);
+    registerContextCommand(program, emit, opts.context);
+    registerScratchCommand(program, emit);
+    registerTunnelCommand(program, emit, opts.context);
+    registerDocsCommand(program, emit, opts.context);
+    registerAgentsCommand(program, emit);
+    registerDoctorCommand(program, emit);
+    registerInitCommand(program, emit, opts.binName);
+    registerUninstallCommand(program, emit);
+    registerBackupCommand(program, emit);
+    registerSyncCommand(program, emit);
+    if (include("web"))
+        registerWebCommand(program, emit);
+    return program;
+}
+function readVersion() {
+    // Static for the empty scaffold. Will be replaced by a build-time substitution
+    // (or a JSON import) once we have any command shipping.
+    return "0.1.0";
+}

package/dist/commands/agents.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `harn agents`: on-demand queries against the multi-agent coord layer.
+ *
+ *   harn agents whoami            current agent's name + instance_id + claims
+ *   harn agents list              all active agents (default: fold transients)
+ *   harn agents list --all        include raw kind=transient rows
+ *   harn agents list --stale      include heartbeats older than the freshness window
+ *   harn agents list --json       JSON output (alias for --format json)
+ *   harn agents status            end-of-turn status box (name + age + files + peers)
+ *   harn agents heal-events       PIDMAP_HEAL telemetry (pid-map self-heal frequency)
+ *   harn agents heal-events --since 24h --limit 20
+ *   harn agents health            one-screen coord-layer health rollup
+ *   harn agents health --since 7d --json
+ */
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+export declare function registerAgentsCommand(program: Command, emitParam: EmitContext): void;
+//# sourceMappingURL=agents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAeH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AA+EnD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CA6OpF"}