hermes-to-claude 0.1.0 → 0.1.2

package/DESIGN.md

@@ -1,4 +1,4 @@
-# H-Bridge (hbridge) Design
+# H-Bridge (h2c) Design
 
 Hermes Bridge — local HTTP bridge from Hermes Agent to Claude Code.
 
@@ -6,11 +6,11 @@ Hermes Bridge — local HTTP bridge from Hermes Agent to Claude Code.
 
 ```
 npm install
-  ├─ preinstall: build → dist/hbridge.mjs + dist/statusline.mjs
+  ├─ preinstall: build → dist/h2c.mjs + dist/statusline.mjs
   ├─ install: npm deps
   └─ postinstall: register statusLine + skill in ~/.claude configs
 
-/hbridge enable
+/h2c enable
   └─ HTTP server on homePort(cwd)
        ├─ GET  /health                   → {"status":"ok"}
        ├─ POST /v1/task/create            → Bridge.createTask(prompt)
@@ -98,7 +98,7 @@ data: {"type":"done","exitCode":0}
 ### Task Lifecycle Diagram
 
 ```
-Hermes                          hbridge:<port>                    Session (Claude Code)
+Hermes                          h2c:<port>                    Session (Claude Code)
   │                                │                                │
   │  POST /v1/task/create          │                                │
   │  {"prompt":"fix bug"}          │                                │
@@ -153,21 +153,21 @@ Hermes                          hbridge:<port>                    Session (Claud
 
 **Key is machine-global**, **port is per-directory**. This follows Claude Code's working-directory-centric model.
 
-Claude Code reads its context — `CLAUDE.md`, project skills, `.claude/settings.json` — from the **current working directory**. Each project has its own conventions, its own skills, its own CLAUDE.md. To serve the right context, hbridge must spawn Claude Code in the right directory.
+Claude Code reads its context — `CLAUDE.md`, project skills, `.claude/settings.json` — from the **current working directory**. Each project has its own conventions, its own skills, its own CLAUDE.md. To serve the right context, h2c must spawn Claude Code in the right directory.
 
 ```
-/project-a/CLAUDE.md  →  hbridge :9200  →  Claude Code (cwd=/project-a)
-/project-b/CLAUDE.md  →  hbridge :9201  →  Claude Code (cwd=/project-b)
+/project-a/CLAUDE.md  →  h2c :9200  →  Claude Code (cwd=/project-a)
+/project-b/CLAUDE.md  →  h2c :9201  →  Claude Code (cwd=/project-b)
 ```
 
 **Port per directory** (`9200 + MD5(cwd) % 600`) means:
 - Each project gets a stable, predictable port
-- You can run hbridge for multiple projects on the same machine without conflict
+- You can run h2c for multiple projects on the same machine without conflict
 - The port is deterministic — Hermes computes it from the directory path without asking the server
 
 **Key per machine** means:
 - Hermes only needs one credential per machine, not one per project
-- The key is random, generated once, persisted in `~/.hbridge_key`
+- The key is random, generated once, persisted in `~/.h2c_key`
 - Same auth works across all directories on the same host
 
 Key format: `hb_` + 8 base52 chars (≈ 45 bits entropy, `crypto.randomBytes(8)`, stored once).
@@ -175,19 +175,19 @@ Key format: `hb_` + 8 base52 chars (≈ 45 bits entropy, `crypto.randomBytes(8)`
 ## Key & Port Derivation
 
 - **Port**: `9200 + (MD5(cwd)[0:2] % 600)` — range [9200, 9799], stable per directory
-- **Key**: `hb_` + 8 random base52 characters — generated once, stored in `~/.hbridge_key`. Same for all directories on one machine.
+- **Key**: `hb_` + 8 random base52 characters — generated once, stored in `~/.h2c_key`. Same for all directories on one machine.
 
 ## Task Persistence
 
-Completed tasks are saved to `~/.hbridge_tasks.jsonl` (JSONL, append-only, max 2000 entries). On server restart, tasks are loaded into memory. `getTaskOutput` checks session → memory cache → disk.
+Completed tasks are saved to `~/.h2c_tasks.jsonl` (JSONL, append-only, max 2000 entries). On server restart, tasks are loaded into memory. `getTaskOutput` checks session → memory cache → disk.
 
 ## Files
 
 ### Runtime (gitignored)
 | File | Purpose |
 |------|---------|
-| `~/.hbridge_state.json` | running/stopped flag + port + lastClientIP/lastActiveAt |
-| `~/.hbridge_tasks.jsonl` | Completed task records (JSONL, survive restart) |
+| `~/.h2c_state.json` | running/stopped flag + port + lastClientIP/lastActiveAt |
+| `~/.h2c_tasks.jsonl` | Completed task records (JSONL, survive restart) |
 
 ### Config (written by postinstall)
 | File | Purpose |
@@ -199,8 +199,8 @@ Completed tasks are saved to `~/.hbridge_tasks.jsonl` (JSONL, append-only, max 2
 Claude Code polls ~3-5s:
 
 ```
-▶️ hbridge: on | :<port>
-⏹️ hbridge: off
+▶️ h2c: on | :<port>
+⏹️ h2c: off
 ```
 
 Liveness is determined by polling `127.0.0.1:<port>/health` — no state-file dependency.
@@ -212,7 +212,7 @@ Liveness is determined by polling `127.0.0.1:<port>/health` — no state-file de
   - Old: `createTask` polled `setInterval` until previous task finished
   - New: Session pool with promise queue — no busy-polling
 - **Task timeout kills queue** ✅ Fixed (see #52)
-- **Persistence**: Completed tasks saved to `~/.hbridge_tasks.jsonl`, survive restart
+- **Persistence**: Completed tasks saved to `~/.h2c_tasks.jsonl`, survive restart
 - **Session class**: One Claude Code child process per task
 - **Parallelism**: Up to 3 concurrent tasks (configurable via `maxConcurrent`)
 
@@ -221,9 +221,9 @@ Liveness is determined by polling `127.0.0.1:<port>/health` — no state-file de
 - Timeout is now opt-in: pass `taskTimeoutMs` to Bridge/Session constructor
 
 ### #53 — Home mode direct enable
-- Home mode (`HBRIDGE_HOME=1`) now calls `cmd_enable()` directly
+- Home mode (`H2C_HOME=1`) now calls `cmd_enable()` directly
 - No longer goes through `--stdio` MCP layer
-- `--stdio` removed — hbridge is HTTP-only
+- `--stdio` removed — h2c is HTTP-only
 
 ### #54+ — Permission pipeline
 - `--dangerously-skip-permissions` replaced by Hermes-controlled permission pipeline

package/README.md

@@ -1,17 +1,17 @@
-# Hermes-Claude-Bridge (hbridge)
+# Hermes-Claude-Bridge (h2c)
 
 **Hermes-Agent** controls multiple **Claude Code** instances via HTTP — one agent, many Claude workers. No Pro/Max subscription required.
 
 ```
-📱 User ----HTTP----> 🤖 Hermes-Agent ----hbridge----> 🏭 Claude Code (deploy role)
-                            ├───hbridge───> 🔧 Claude Code (coding role)
-                            ├───hbridge───> 🧪 Claude Code (testing role)
-                            └───hbridge───> 🔬 Claude Code (building role)
+📱 User ----HTTP----> 🤖 Hermes-Agent ----h2c----> 🏭 Claude Code (deploy role)
+                            ├───h2c───> 🔧 Claude Code (coding role)
+                            ├───h2c───> 🧪 Claude Code (testing role)
+                            └───h2c───> 🔬 Claude Code (building role)
 ```
 
 ---
 
-## 1. hbridge Advantages
+## 1. h2c Advantages
 
 - **No Pro/Max required** — works with any Claude Code via stdio; no Anthropic subscription needed.
 - **One agent, many Claudes** — one Hermes-Agent routes tasks to multiple Claude Code instances, each in its own project directory with its own CLAUDE.md and skills.
@@ -25,7 +25,7 @@
 
 ### Prepare
 
-hbridge requires **Node.js ≥ 20**. Install it for your platform:
+h2c requires **Node.js ≥ 20**. Install it for your platform:
 
 | Platform | Command |
 |----------|---------|
@@ -43,24 +43,24 @@ npm install && npm run build
 
 ### Start in Claude Code
 
-After installation, enable hbridge from inside Claude Code:
+After installation, enable h2c from inside Claude Code:
 
 ```
-/hbridge enable
+/h2c enable
 ```
 
 This starts the HTTP server. The port is derived from the working directory (see Authentication and Port below). Check status at any time:
 
 ```
-/hbridge status
+/h2c status
 ```
 
 ### Home Mode — For Headless Machines
 
-When Hermes-Agent runs on a server with no display, no manual command is needed. Export the **environment variable** before starting hbridge:
+When Hermes-Agent runs on a server with no display, no manual command is needed. Export the **environment variable** before starting h2c:
 
 ```bash
-export HBRIDGE_HOME=1       # environment variable — auto-starts hbridge
+export H2C_HOME=1       # environment variable — auto-starts h2c
 ```
 
 With Home mode active, the server listens on `127.0.0.1` only. Authentication is **disabled** — safe because only local processes can reach it. Hermes-Agent connects without managing keys.
@@ -73,17 +73,17 @@ The port is **deterministic**: `MD5(cwd)` → first 2 bytes → `9200 + (value %
 - Claude reads its own CLAUDE.md, skills, and project files from that directory
 - Port = project — you always know which Claude you're talking to
 
-The auth key (`hb_` + 8 random base52 characters) is written to `~/.hbridge_key` once and reused across all directories on the same machine. All HTTP endpoints (except `/health`) require HTTP Basic Auth with username `bridge` and the key as password.
+The auth key (`hb_` + 8 random base52 characters) is written to `~/.h2c_key` once and reused across all directories on the same machine. All HTTP endpoints (except `/health`) require HTTP Basic Auth with username `bridge` and the key as password.
 
 ---
 
 ## 3. For Hermes-Agent
 
-Hermes-Agent discovers and controls hbridge via HTTP. Here is the complete API.
+Hermes-Agent discovers and controls h2c via HTTP. Here is the complete API.
 
 ### Security
 
-Like Claude Code CLI, hbridge requires authentication for all mutating endpoints. But Hermes-Agent can simplify — either handle the auth flow itself, or bypass it entirely with `skip_permissions` for trusted workloads. Hermes-Agent must handle the same authentication and permission flow that human users would, or explicitly choose to bypass it.
+Like Claude Code CLI, h2c requires authentication for all mutating endpoints. But Hermes-Agent can simplify — either handle the auth flow itself, or bypass it entirely with `skip_permissions` for trusted workloads. Hermes-Agent must handle the same authentication and permission flow that human users would, or explicitly choose to bypass it.
 
 ### Create a Task
 
@@ -145,7 +145,7 @@ curl -X POST http://<host>:<port>/v1/task/cancel \
 
 ### Permission Pipeline
 
-hbridge includes a full permission pipeline — just like CI tools. Hermes-Agent can decide per-task how to handle tool approvals:
+h2c includes a full permission pipeline — just like CI tools. Hermes-Agent can decide per-task how to handle tool approvals:
 
 | Mode | Behavior |
 |------|----------|
@@ -158,7 +158,7 @@ For quick development tasks, use `skip_permissions`. For production workloads th
 ### Architecture
 
 ```
-Hermes ──HTTP──▶ hbridge :<port> ──spawn──▶ Session (Claude Code)
+Hermes ──HTTP──▶ h2c :<port> ──spawn──▶ Session (Claude Code)
   │                   │                              │
   │  Control Layer    │  server.mjs (HTTP routing)    │  reads CLAUDE.md
   │  (create/cancel/  │  bridge.mjs (session pool)    │  loads skills
@@ -206,7 +206,7 @@ Event types pushed over SSE:
 
 #### NDJSON Transcript
 
-The raw Claude Code stdout is saved to `~/.hbridge_transcript.jsonl`. Each line is a complete NDJSON message from Claude Code — `assistant` messages, `stream_event` deltas, `tool_use` blocks, and `result` messages with usage data:
+The raw Claude Code stdout is saved to `~/.h2c_transcript.jsonl`. Each line is a complete NDJSON message from Claude Code — `assistant` messages, `stream_event` deltas, `tool_use` blocks, and `result` messages with usage data:
 
 ```jsonl
 {"type":"stream_event","event":{"type":"content_block_delta","delta":{"type":"text_delta","text":"Fixing"}}}
@@ -223,7 +223,7 @@ Hermes-Agent can tail this file for full Claude Code session history, or consume
 | Document | Contents |
 |----------|----------|
 | [DESIGN.md](DESIGN.md) | Architecture, protocol, session lifecycle, permission pipeline, API reference, changelog |
-| [docs/local-mode.md](docs/local-mode.md) | HBRIDGE_HOME auto-start mode |
+| [docs/local-mode.md](docs/local-mode.md) | H2C_HOME auto-start mode |
 | [docs/spawn-mechanism.md](docs/spawn-mechanism.md) | Claude Code spawn protocol, NDJSON format |
 | [docs/mcp-spec.md](docs/mcp-spec.md) | MCP tool definitions (Claude Code integration) |
 

package/build.mjs

@@ -9,10 +9,10 @@ const SRC_DIR = path.resolve(__dirname, 'src')
 // Generate version from git
 const count = execSync("git rev-list --count HEAD", { encoding: "utf8" }).trim();
 const hash = execSync("git rev-parse --short HEAD", { encoding: "utf8" }).trim();
-const HBRIDGE_VERSION = `v${count}.0.${hash}`;
-console.log(`✓ version ${HBRIDGE_VERSION}`);
+const H2C_VERSION = `v${count}.0.${hash}`;
+console.log(`✓ version ${H2C_VERSION}`);
 
-// Build hbridge CLI
+// Build h2c CLI (dist/hbridge.mjs)
 await esbuild.build({
   entryPoints: [path.join(SRC_DIR, 'hbridge', 'cli.mjs')],
   bundle: true,
@@ -21,7 +21,7 @@ await esbuild.build({
   outfile: 'dist/hbridge.mjs',
   external: ['zod', 'chalk', 'axios', '@anthropic-ai/sdk', 'qrcode', 'lodash-es', 'get-east-asian-width'],
   define: {
-    'globalThis.HBRIDGE_VERSION': JSON.stringify(HBRIDGE_VERSION),
+    'globalThis.H2C_VERSION': JSON.stringify(H2C_VERSION),
   },
 });
 

package/dist/hbridge.mjs

@@ -248,7 +248,7 @@ var StdioTransport = class {
     });
     this._transcriptPath = opts.transcriptPath;
     if (this._transcriptPath === void 0) {
-      this._transcriptPath = join(homedir(), ".hbridge_transcript.jsonl");
+      this._transcriptPath = join(homedir(), ".h2c_transcript.jsonl");
     }
     this._transcriptStream = null;
     this._uploader = new SerialBatchEventUploader({
@@ -982,7 +982,7 @@ ${resultText}
 import { readFileSync, appendFileSync, writeFileSync, existsSync } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
-var TASKS_FILE = join2(homedir2(), ".hbridge_tasks.jsonl");
+var TASKS_FILE = join2(homedir2(), ".h2c_tasks.jsonl");
 var MAX_TASKS = 2e3;
 function appendCompletedTask(task) {
   if (!task || !task.id) return;
@@ -1051,7 +1051,7 @@ function trimCompletedTasks() {
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
-var STATE_FILE = join3(homedir3(), ".hbridge_state.json");
+var STATE_FILE = join3(homedir3(), ".h2c_state.json");
 var DEFAULT_STATE = {
   running: false,
   port: 9190,
@@ -1412,9 +1412,9 @@ import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsS
 import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
 var BASE52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-var KEY_FILE = join4(homedir4(), ".hbridge_key");
+var KEY_FILE = join4(homedir4(), ".h2c_key");
 function isHome() {
-  return process.env.HBRIDGE_HOME == 1;
+  return process.env.H2C_HOME == 1;
 }
 function homePort(cwd) {
   const hash = createHash("md5").update(Buffer.from(cwd, "utf-8")).digest();
@@ -1423,12 +1423,12 @@ function homePort(cwd) {
 function homeKey(_cwd) {
   if (existsSync3(KEY_FILE)) {
     const existing = readFileSync3(KEY_FILE, "utf8").trim();
-    if (existing && existing.startsWith("hb_")) {
+    if (existing && existing.startsWith("h2c_")) {
       return existing;
     }
   }
   const bytes = randomBytes(8);
-  let key = "hb_";
+  let key = "h2c_";
   for (const byte of bytes) {
     key += BASE52[byte % 52];
   }
@@ -1571,7 +1571,7 @@ function createServer(expectedKey, bridge = new Bridge()) {
 function startStatusBar(port) {
   function render() {
     const uptime = Math.floor((Date.now() - startTime) / 6e4);
-    process.stdout.write(`\r  hbridge: on | port: ${port} | ${taskCount} tasks | \u2191 ${uptime}min  `);
+    process.stdout.write(`\r  h2c: on | port: ${port} | ${taskCount} tasks | \u2191 ${uptime}min  `);
   }
   render();
   return setInterval(render, 5e3);
@@ -1582,7 +1582,7 @@ function stopStatusBar(intervalId) {
 
 // src/hbridge/cli.mjs
 import { networkInterfaces } from "os";
-var HBRIDGE_VERSION = "v177.0.c21a99a";
+var H2C_VERSION = "v184.0.572153f";
 var server = null;
 var statusBarInterval = null;
 function getLocalIPs() {
@@ -1594,13 +1594,13 @@ async function cmd_enable() {
   const key = homeKey(cwd);
   const ips = getLocalIPs();
   const ip = isHome() ? "127.0.0.1" : ips[0] || "127.0.0.1";
-  console.log("hbridge enabled");
+  console.log("h2c enabled");
   console.log("\u{1F4C2} " + cwd);
-  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + HBRIDGE_VERSION);
+  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + H2C_VERSION);
   server = createServer(key);
   server.on("error", (err) => {
     if (err.code === "EADDRINUSE") {
-      process.stderr.write(`Port ${port} already in use \u2014 hbridge may already be running
+      process.stderr.write(`Port ${port} already in use \u2014 h2c may already be running
 `);
     } else {
       process.stderr.write(`Server error: ${err.message}
@@ -1617,14 +1617,14 @@ function cmd_disable() {
     server.close(() => {
       server = null;
       markStopped();
-      console.log("  hbridge: off");
+      console.log("  h2c: off");
       stopStatusBar(statusBarInterval);
       process.exit(0);
     });
     setTimeout(() => process.exit(0), 1e3);
   } else {
     markStopped();
-    console.log("  hbridge: off");
+    console.log("  h2c: off");
     process.exit(0);
   }
 }
@@ -1636,26 +1636,26 @@ function cmd_status() {
   const state = readState();
   const ip = isHome() ? "127.0.0.1" : ips[0] || "127.0.0.1";
   const running = state.running;
-  console.log(running ? "hbridge enabled" : "hbridge stopped");
+  console.log(running ? "h2c enabled" : "h2c stopped");
   console.log("\u{1F4C2} " + cwd);
-  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + HBRIDGE_VERSION);
+  console.log("\u{1F511} " + ip + ":" + port + " | " + key + " | " + H2C_VERSION);
 }
 function showHelp() {
   console.log(`
-  hbridge \u2014 Hermes Bridge
+  h2c \u2014 Hermes Bridge
 
   COMMANDS:
-    hbridge --enable         Start bridge with deterministic key
-    hbridge --disable        Stop bridge
-    hbridge --status         Show status + last client connection
-    hbridge --help           Show this help
+    h2c --enable         Start bridge with deterministic key
+    h2c --disable        Stop bridge
+    h2c --status         Show status + last client connection
+    h2c --help           Show this help
 
-  Port is derived from the working directory; key is machine-global from ~/.hbridge_key.
-  Home mode (HBRIDGE_HOME=1) skips auth; remote mode enforces key.
+  Port is derived from the working directory; key is machine-global from ~/.h2c_key.
+  Home mode (H2C_HOME=1) skips auth; remote mode enforces key.
 
   EXAMPLES:
-    hbridge --enable         Enable with dir-derived key
-    hbridge --status         Show connected IP + last active time
+    h2c --enable         Enable with dir-derived key
+    h2c --status         Show connected IP + last active time
   `);
   process.exit(0);
 }
@@ -1669,9 +1669,9 @@ else if (cmd === "--status") cmd_status();
 else if (cmd === "--help" || cmd === "-h") {
   showHelp();
 } else {
-  console.log("hbridge \u2014 Hermes Bridge");
-  console.log("  hbridge --enable           Start bridge");
-  console.log("  hbridge --disable          Stop bridge");
-  console.log("  hbridge --status           Show status");
-  console.log("  hbridge --help             Show help");
+  console.log("h2c \u2014 Hermes Bridge");
+  console.log("  h2c --enable           Start bridge");
+  console.log("  h2c --disable          Stop bridge");
+  console.log("  h2c --status           Show status");
+  console.log("  h2c --help             Show help");
 }

package/dist/statusline.mjs

@@ -35,8 +35,8 @@ async function main() {
   const port = portFromCwd(process.cwd());
   const alive = await livenessCheck(port);
   const lastDir = process.cwd().split(/[/\\]/).filter(Boolean).pop() || process.cwd();
-  const hbStatus = alive ? `\u25B6\uFE0F hbridge: on | :${port} | ${lastDir}` : `\u23F9\uFE0F hbridge: off`;
-  const userCmdFile = join(homedir(), ".hbridge_user_statusline_cmd");
+  const hbStatus = alive ? `\u25B6\uFE0F h2c: on | :${port} | ${lastDir}` : `\u23F9\uFE0F h2c: off`;
+  const userCmdFile = join(homedir(), ".h2c_user_statusline_cmd");
   let userPart = "";
   if (existsSync(userCmdFile)) {
     try {

package/docs/local-mode.md

@@ -1,42 +1,42 @@
-# hbridge Home Local Mode
+# h2c Home Local Mode
 
-Zero-config local collaboration between Hermes and Claude (OOB — Out-Of-Box). Unlike remote mode (manual `/hbridge enable` + authentication required), local mode starts **automatically, with no auth, and lives as long as Claude does**.
+Zero-config local collaboration between Hermes and Claude (OOB — Out-Of-Box). Unlike remote mode (manual `/h2c enable` + authentication required), local mode starts **automatically, with no auth, and lives as long as Claude does**.
 
 ## Motivation
 
-A general-purpose AI agent (Hermes) cannot remember domain specifics — experience is locked in skill files. hbridge Home Local Mode lets Hermes focus on orchestration only, delegating skills, scripts, and workflows to Claude. Claude owns one task at a time with zero memory pollution.
+A general-purpose AI agent (Hermes) cannot remember domain specifics — experience is locked in skill files. h2c Home Local Mode lets Hermes focus on orchestration only, delegating skills, scripts, and workflows to Claude. Claude owns one task at a time with zero memory pollution.
 
 ```
-Hermes → HBRIDGE_HOME=1 → hbridge auto-starts → compute port from cwd → connect localhost → send task → read result
+Hermes → H2C_HOME=1 → h2c auto-starts → compute port from cwd → connect localhost → send task → read result
 Claude → read CLAUDE.md → load skill → execute → respond
 ```
 
 ## Trigger
 
-Hermes sets the environment variable `HBRIDGE_HOME=1` and hbridge picks it up automatically — zero user action. No MCP config changes, no Claude involvement needed.
+Hermes sets the environment variable `H2C_HOME=1` and h2c picks it up automatically — zero user action. No MCP config changes, no Claude involvement needed.
 
 ```bash
-HBRIDGE_HOME=1 node dist/hbridge.mjs
+H2C_HOME=1 node dist/h2c.mjs
 ```
 
-When running as a standalone CLI, hbridge auto-starts if no subcommand is given and `HBRIDGE_HOME=1`:
+When running as a standalone CLI, h2c auto-starts if no subcommand is given and `H2C_HOME=1`:
 
 ```bash
-HBRIDGE_HOME=1 node dist/hbridge.mjs
-# → hbridge enabled (auto-start)
+H2C_HOME=1 node dist/h2c.mjs
+# → h2c enabled (auto-start)
 ```
 
 ## Behavioral Differences
 
 | | Remote Mode | Home Mode |
 |------|-------------|-----------|
-| Startup | Manual `/hbridge enable` | **Auto-start** (calls `hbridge enable` internally) |
+| Startup | Manual `/h2c enable` | **Auto-start** (calls `h2c enable` internally) |
 | Auth | Basic Auth required (machine key) | **No auth** (localhost trust) |
 | Port | hash(cwd) → [9200, 9799] | **hash(cwd)** → [9200, 9799] |
 | Listen | All interfaces (0.0.0.0) | **127.0.0.1 only** |
 | Lifecycle | Manual `--disable` | **Auto-stop on process exit** (HTTP server lives in same Node process) |
 
-Both modes use the same machine-global key (stored in `~/.hbridge_key`); home mode simply skips the auth check.
+Both modes use the same machine-global key (stored in `~/.h2c_key`); home mode simply skips the auth check.
 
 ## Port Mapping
 
@@ -48,11 +48,11 @@ Each working directory gets a deterministic port, stable across runs and machine
 
 ## Implementation
 
-Implemented in `src/hbridge/home.mjs`:
+Implemented in `src/h2c/home.mjs`:
 
-1. `isHome()` — checks `HBRIDGE_HOME == 1` (strict)
+1. `isHome()` — checks `H2C_HOME == 1` (strict)
 2. `homePort(cwd)` — returns `9200 + MD5(cwd)[0:2] % 600` (range [9200, 9799])
-3. `homeKey()` — reads/generates machine-global key in `~/.hbridge_key`
+3. `homeKey()` — reads/generates machine-global key in `~/.h2c_key`
 
 Server behavior when home mode is active:
 - **HTTP server** (`server.mjs`): skips auth, listens on `127.0.0.1`
@@ -64,4 +64,4 @@ Identical to remote mode — only port derivation and auth differ.
 
 ## Status
 
-**Implemented and active.** First-class feature, not experimental. See `src/hbridge/home.mjs` for the implementation and `tests/test_home.mjs` for test coverage.
+**Implemented and active.** First-class feature, not experimental. See `src/h2c/home.mjs` for the implementation and `tests/test_home.mjs` for test coverage.

package/docs/mcp-spec.md

@@ -1,85 +1,85 @@
-# MCP Protocol Spec — hbridge Mapping
-
-Spec: https://modelcontextprotocol.io/specification/2024-11-05
-
-## 1. Lifecycle — Initialization
-
-**Spec ref**: `Specification → Base Protocol → Lifecycle → Initialization`
-
-**Sequence**:
-```
-Client → Server:  initialize  (protocolVersion + capabilities + clientInfo)
-Server → Client:  initialize response (protocolVersion + capabilities + serverInfo)
-Client → Server:  notifications/initialized  (no response needed)
-```
-
-**hbridge implementation**: `mcp.mjs` lines 79-88
-
-## 2. Capabilities — tools MUST declare listChanged
-
-**Spec ref**: `Specification → Server Features → Tools → Capabilities`
-
-**Spec quote**: "Servers that support tools MUST declare the tools capability"
-```
-{"capabilities": {"tools": {"listChanged": true}}}
-```
-
-**hbridge implementation**: `mcp.mjs` line 85 — `capabilities: { tools: { listChanged: true } }`
-
-## 3. Tool Definition Format
-
-**Spec ref**: `Specification → Server Features → Tools → Data Types → Tool`
-
-**Fields**:
-- `name` (string, required) — unique tool name
-- `description` (string, optional) — human-readable description
-- `inputSchema` (object, required) — JSON Schema for tool parameters
-
-**hbridge implementation**: `mcp.mjs` TOOLS array, lines 292-322 — all 4 tools have name + description + inputSchema
-
-## 4. tools/list Response
-
-**Spec ref**: `Specification → Server Features → Tools → Protocol Messages → Listing Tools`
-
-**Response format**:
-```
-{"tools": [Tool, Tool, ...]}
-```
-
-**hbridge implementation**: `mcp.mjs` line 89 — respond({ result: { tools: TOOLS } })
-
-## 5. tools/call Response
-
-**Spec ref**: `Specification → Server Features → Tools → Data Types → Text Content`
-
-**Format**:
-```
-{"content": [{"type": "text", "text": "result string"}]}
-```
-
-**hbridge implementation**: `mcp.mjs` lines 161-164 — respond({ result: { content: [{ type: "text", text: t }] } })
-
-## 6. Available Tools
-
-| Tool | Description |
-|------|-------------|
-| `hbridge_enable` | Start hbridge HTTP server, show access key |
-| `hbridge_disable` | Stop hbridge server |
-| `hbridge_status` | Show server status + last client connection info |
-| `hbridge_status_bar` | Show/hide hbridge status in Claude Code status bar |
-
-## 7. Additional Features
-
-- **Stdout guard** (`mcp.mjs` lines 25-32): Non-JSON stdout writes are redirected to stderr to prevent third-party console.log from corrupting the MCP JSON-RPC stream.
-- **Crash protection** (`mcp.mjs` lines 35-40): `uncaughtException` and `unhandledRejection` handlers keep the MCP process alive.
-- **HTTP inbox server** (`mcp.mjs` lines 180-285): When `HBRIDGE_HOME=1`, the MCP server also auto-starts an HTTP server on the deterministic port.
-- **Server info**: `serverInfo: { name: "hbridge", version: "1.0.0" }` in initialize response.
-
-## 8. Validation Results
-
-```
-✅ initialize   → protocolVersion:2024-11-05, capabilities.listChanged:true
-✅ tools/list   → 4 tools with name+description+inputSchema
-✅ tools/call   → content[{type:text,text:...}]
-✅ notified/init → silent accept
-```
+# MCP Protocol Spec — h2c Mapping
+
+Spec: https://modelcontextprotocol.io/specification/2024-11-05
+
+## 1. Lifecycle — Initialization
+
+**Spec ref**: `Specification → Base Protocol → Lifecycle → Initialization`
+
+**Sequence**:
+```
+Client → Server:  initialize  (protocolVersion + capabilities + clientInfo)
+Server → Client:  initialize response (protocolVersion + capabilities + serverInfo)
+Client → Server:  notifications/initialized  (no response needed)
+```
+
+**h2c implementation**: `mcp.mjs` lines 79-88
+
+## 2. Capabilities — tools MUST declare listChanged
+
+**Spec ref**: `Specification → Server Features → Tools → Capabilities`
+
+**Spec quote**: "Servers that support tools MUST declare the tools capability"
+```
+{"capabilities": {"tools": {"listChanged": true}}}
+```
+
+**h2c implementation**: `mcp.mjs` line 85 — `capabilities: { tools: { listChanged: true } }`
+
+## 3. Tool Definition Format
+
+**Spec ref**: `Specification → Server Features → Tools → Data Types → Tool`
+
+**Fields**:
+- `name` (string, required) — unique tool name
+- `description` (string, optional) — human-readable description
+- `inputSchema` (object, required) — JSON Schema for tool parameters
+
+**h2c implementation**: `mcp.mjs` TOOLS array, lines 292-322 — all 4 tools have name + description + inputSchema
+
+## 4. tools/list Response
+
+**Spec ref**: `Specification → Server Features → Tools → Protocol Messages → Listing Tools`
+
+**Response format**:
+```
+{"tools": [Tool, Tool, ...]}
+```
+
+**h2c implementation**: `mcp.mjs` line 89 — respond({ result: { tools: TOOLS } })
+
+## 5. tools/call Response
+
+**Spec ref**: `Specification → Server Features → Tools → Data Types → Text Content`
+
+**Format**:
+```
+{"content": [{"type": "text", "text": "result string"}]}
+```
+
+**h2c implementation**: `mcp.mjs` lines 161-164 — respond({ result: { content: [{ type: "text", text: t }] } })
+
+## 6. Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `h2c_enable` | Start h2c HTTP server, show access key |
+| `h2c_disable` | Stop h2c server |
+| `h2c_status` | Show server status + last client connection info |
+| `h2c_status_bar` | Show/hide h2c status in Claude Code status bar |
+
+## 7. Additional Features
+
+- **Stdout guard** (`mcp.mjs` lines 25-32): Non-JSON stdout writes are redirected to stderr to prevent third-party console.log from corrupting the MCP JSON-RPC stream.
+- **Crash protection** (`mcp.mjs` lines 35-40): `uncaughtException` and `unhandledRejection` handlers keep the MCP process alive.
+- **HTTP inbox server** (`mcp.mjs` lines 180-285): When `H2C_HOME=1`, the MCP server also auto-starts an HTTP server on the deterministic port.
+- **Server info**: `serverInfo: { name: "h2c", version: "1.0.0" }` in initialize response.
+
+## 8. Validation Results
+
+```
+✅ initialize   → protocolVersion:2024-11-05, capabilities.listChanged:true
+✅ tools/list   → 4 tools with name+description+inputSchema
+✅ tools/call   → content[{type:text,text:...}]
+✅ notified/init → silent accept
+```

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "hermes-to-claude",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Local HTTP bridge connecting Hermes Agent to Claude Code — no Pro/Max subscription required",
   "license": "MIT",
-  "repository": "github:xuhancn/hermes-claude-bridge",
+  "repository": "github:xuhancn/hermes-to-claude",
   "bin": {
     "h2c": "dist/hbridge.mjs"
   },

package/scripts/setup-mcp.cjs

@@ -12,14 +12,14 @@ const USER_SKILL_DIR = path.join(
   process.env.HOME || os.homedir(),
   ".claude",
   "skills",
-  "hbridge",
+  "h2c",
 );
 
 try {
   // ---- statusLine hook (default ON — attaches to user's existing bar) ----
   const STATUSBAR_PATH = path.join(__dirname, "..", "dist", "statusline.mjs");
   const cmd = `node ${STATUSBAR_PATH}`;
-  const USER_CMD_FILE = path.join(os.homedir(), ".hbridge_user_statusline_cmd");
+  const USER_CMD_FILE = path.join(os.homedir(), ".h2c_user_statusline_cmd");
 
   let settings = {};
   if (fs.existsSync(USER_SETTINGS)) {
@@ -35,19 +35,19 @@ try {
 
   fs.mkdirSync(path.dirname(USER_SETTINGS), { recursive: true });
   fs.writeFileSync(USER_SETTINGS, JSON.stringify(settings, null, 2));
-  console.log("✓ hbridge statusLine registered (attaches to existing bar)");
+  console.log("✓ h2c statusLine registered (attaches to existing bar)");
 
-  // ---- /hbridge slash command skill (global ~/.claude/skills/hbridge/) ----
-  const SKILL_SRC = path.join(__dirname, "..", ".claude", "skills", "hbridge", "SKILL.md");
+  // ---- /h2c slash command skill (global ~/.claude/skills/h2c/) ----
+  const SKILL_SRC = path.join(__dirname, "..", ".claude", "skills", "h2c", "SKILL.md");
   const SKILL_DST = path.join(USER_SKILL_DIR, "SKILL.md");
 
   if (fs.existsSync(SKILL_SRC)) {
     fs.mkdirSync(USER_SKILL_DIR, { recursive: true });
     fs.copyFileSync(SKILL_SRC, SKILL_DST);
-    console.log("✓ hbridge slash command installed (/hbridge)");
+    console.log("✓ h2c slash command installed (/h2c)");
   } else {
-    console.warn("⚠ hbridge skill file not found — skipping slash command install");
+    console.warn("⚠ h2c skill file not found — skipping slash command install");
   }
 } catch (e) {
-  console.error("⚠ Could not register hbridge in Claude Code config:", e.message);
+  console.error("⚠ Could not register h2c in Claude Code config:", e.message);
 }