openhermes 2.8.0 → 4.0.1

package/bootstrap.mjs

@@ -1,512 +1,174 @@
-import path from "node:path"
-import fs from "node:fs"
-import os from "node:os"
-import { fileURLToPath } from "node:url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const CONFIG_DIR = path.join(os.homedir(), ".config", "opencode")
-const OVERRIDE_SOUL = path.join(CONFIG_DIR, "SOUL.md")
-const REQUIRED_HARNESS_FILES = [
-  ["codex", "CONSTITUTION.md"],
-  ["instructions", "RUNTIME.md"],
-  ["commands", "doctor.md"],
-  ["prompts", "architect.txt"],
-  ["rules", "precedence.md"],
-  ["skills", "coding-standards", "SKILL.md"],
-]
-
-function ancestorDirs(start, limit = 6) {
-  const dirs = []
-  let current = path.resolve(start)
-  for (let i = 0; i < limit; i++) {
-    dirs.push(current)
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return dirs
-}
-
-function buildHarnessCandidates(currentDir, execPath, cwd) {
-  const roots = [path.resolve(currentDir, "harness")]
-  const seen = new Set(roots)
-
-  const anchors = [path.dirname(execPath), path.dirname(path.dirname(execPath)), cwd]
-  for (const anchor of anchors) {
-    for (const dir of ancestorDirs(anchor)) {
-      for (const root of [
-        path.join(dir, "harness"),
-        path.join(dir, "node_modules", "openhermes", "harness"),
-        path.join(dir, "bin", "node_modules", "openhermes", "harness"),
-      ]) {
-        const normalized = path.normalize(root)
-        if (seen.has(normalized)) continue
-        seen.add(normalized)
-        roots.push(normalized)
-      }
-    }
-  }
-
-  return roots
-}
-
-function hasRequiredHarnessFiles(root) {
-  return REQUIRED_HARNESS_FILES.every(parts => fs.existsSync(path.join(root, ...parts)))
-}
-
-export function resolveHarnessRoot({
-  currentDir = __dirname,
-  execPath = process.execPath,
-  cwd = process.cwd(),
-  candidateRoots,
-} = {}) {
-  const roots = candidateRoots ?? buildHarnessCandidates(currentDir, execPath, cwd)
-  for (const root of roots) {
-    if (hasRequiredHarnessFiles(root)) return root
-  }
-  return path.resolve(currentDir, "harness")
-}
-
-let _harnessDir
-export function setHarnessRootForTest(dir) { _harnessDir = dir }
-export function getHarnessDir() {
-  if (!_harnessDir) _harnessDir = resolveHarnessRoot()
-  return _harnessDir
-}
-function getRulesDir() { return path.join(getHarnessDir(), "rules") }
-function getSkillsDir() { return path.join(getHarnessDir(), "skills") }
-function getConstitutionFile() { return path.join(getHarnessDir(), "codex", "CONSTITUTION.md") }
-function getRuntimeFile() { return path.join(getHarnessDir(), "instructions", "RUNTIME.md") }
-
-
-function scanDirNames(dir) {
-  try { return fs.readdirSync(dir).filter(f => f.endsWith(".md")).map(f => f.replace(/\.md$/, "")).sort() }
-  catch { return [] }
-}
-
-function scanPromptNames(dir) {
-  try { return fs.readdirSync(dir).filter(f => f.endsWith('.md') || f.endsWith('.txt')).map(f => path.basename(f, path.extname(f))).sort() }
-  catch { return [] }
-}
-
-function scanSkillDirs(dir) {
-  try { return fs.readdirSync(dir).filter(f => fs.statSync(path.join(dir, f)).isDirectory()).sort() }
-  catch { return [] }
-}
-
-function scanSchemaNames(dir) {
-  try { return fs.readdirSync(dir).filter(f => f.endsWith(".schema.json")).map(f => f.replace(/\.schema\.json$/, "")).filter(f => f !== "loop-state").sort() }
-  catch { return [] }
-}
-
-export function buildCapabilityMap(hDir) {
-  const cmds = scanDirNames(path.join(hDir, "commands"))
-  if (!cmds.includes("update-me")) cmds.push("update-me")
-  cmds.sort()
-
-  const agents = scanPromptNames(path.join(hDir, "prompts"))
-  const skills = scanSkillDirs(path.join(hDir, "skills"))
-  const schemas = scanSchemaNames(path.join(__dirname, "schemas"))
-
-  return [
-    "## Capability Map",
-    "",
-    `Commands  (${cmds.length}):  /${cmds.join(" /")}`,
-    `Subagents (${agents.length}): ${agents.join(" ")}`,
-    `Skills    (${skills.length}): ${skills.join(" ")}`,
-    `Memory    (${schemas.length}): ${schemas.join(" ")}`,
-    "",
-    `For problem → specialist routing see Delegation below. Skills via \`skill\` tool. Memory via \`ohc_save\` etc.`,
-  ].join("\n")
-}
-
-export function loadLocalSoulOverride(overridePath) {
-  const filePath = overridePath || OVERRIDE_SOUL
-  try {
-    if (fs.existsSync(filePath)) {
-      const text = fs.readFileSync(filePath, "utf8").trim()
-      if (text) return text
-    }
-  } catch {}
-  return null
-}
-
-function buildBootstrapContent() {
-  let constitution = fs.readFileSync(getConstitutionFile(), "utf8")
-  const localOverride = loadLocalSoulOverride()
-  if (localOverride) {
-    constitution += `\n\n## Local Overrides (survives reinstalls)\n\n${localOverride}`
-  }
-  const runtime = fs.readFileSync(getRuntimeFile(), "utf8")
-  const capMap = buildCapabilityMap(getHarnessDir())
-
-  const router = `## AGENTS.md
-
-OpenHermes thin constitutional router. Full harness → \`openhermes/harness/\`.
-
-## Constitution
-
-Pragmatic. Concise. Task-oriented. Subagent-first. Inspect, then act. Scope to the problem. Verify, don't claim. Receipts over vibes. Recover by narrowing, not posturing. Skeptical — demand proof. Precision-first search: needle then broad, never reverse.
-
-## Safety
-
-Snapshot before mutation. Never delete unrelated files. Never assume \`%USERPROFILE%\\.config\\opencode\` is a git repo. Verify or roll back. **NEVER delete \`auth.json\`** (\`%USERPROFILE%\\.local\\share\\opencode\\auth.json\`).
-
-${capMap}
-
-## Delegation (Mandatory)
-
-Main context = coordination + verification only. Substantive work → subagent.
-
-| Trigger | Subagent |
-|---------|----------|
-| Multi-file implementation | \`architect\` or \`planner\` |
-| Build/TS error | \`build-error-resolver\` |
-| Code review | \`code-reviewer\` |
-| Security audit | \`security-reviewer\` |
-| E2E testing | \`e2e-runner\` |
-| Multi-file search/exploration | \`explore\` or \`general\` |
-| Documentation lookup | \`docs-lookup\` |
-| Doc/codemap update | \`doc-updater\` |
-| Dead code cleanup | \`refactor-cleaner\` |
-| TDD workflow | \`tdd-guide\` |
-| Autonomous loop | \`loop-operator\` |
-| Go review | \`review-go\` |
-| Go build fix | \`build-go\` |
-| Database review | \`review-database\` |
-| C++ review | \`review-cpp\` |
-| Java review | \`review-java\` |
-| Java build fix | \`build-java\` |
-| Kotlin review | \`review-kotlin\` |
-| Kotlin build fix | \`build-kotlin\` |
-| Python review | \`review-python\` |
-| Rust review | \`review-rust\` |
-| Rust build fix | \`build-rust\` |
-| Any non-trivial multi-step | appropriate specialist |
-
-Never delegate trivial single-step ops. Subagent returns diff + summary + verification; inspect return only. Full ref: \`openhermes/harness/rules/delegation.md\`.
-
-## Handoff Protocol
-
-Every agent knows its role, permissions, and when to delegate. Before delegating, assess task complexity (easy → direct, medium → single subagent, hard → sequential multi-agent, very-large → fan-out). Use structured handoff format documented in \`openhermes/harness/rules/handoff.md\`.
-
-- **Act**: Task matches your role and permissions → do it directly
-- **Delegate**: Task outside your role → pass to correct agent via \`task\` tool
-- **Escalate**: Review/planning agents must NEVER edit code. Delegate to builders.
-- **Learn**: After each task, check for repeated patterns. Persist to memory via \`ohc_save\`.
-- **Checkpoint**: Before every handoff, save a checkpoint.
-
-## Memory — Gated & Precision-First
-
-- **Start**: Read recall cache first. If stale/missing → \`ohc_latest\` for relevant classes.
-- **Before work**: Narrow \`ohc_search\` by class, scope, keywords. Never read full indexes.
-- **Before close**: Query same-type mistakes (7 days). Match → \`code-reviewer\` or \`security-reviewer\`.
-- **On failure**: \`ohc_search\` for similar incidents. Search memory before asking user.
-- **Precision ladder**: \`ohc_latest\` → \`ohc_search\` → \`ohc_get\` → \`ohc_list\` (last resort). Full index reads only for explicit audit/repair tasks.
-- **Anti-spam**: No obvious facts, no one-off prefs, no temp state, no low-risk mistakes. Supersede, don't duplicate. Full rules: \`openhermes/harness/rules/retrieval.md\`, \`openhermes/harness/rules/memory-management.md\`.
-
-## Self-Edit Authority
-
-| Auto | Conditional | Needs approval |
-|------|-------------|----------------|
-| Memory entries, mistakes, checkpoints, receipts | openhermes docs/schemas/templates/non-core rules patches | AGENTS.md core, model routing, permissions, config, protected settings |
-
-Full tiers: \`openhermes/harness/rules/self-heal.md\`.
-
-## Precedence
-
-1. User instruction. 2. Safety/legal/destructive guard. 3. Constitution (\`openhermes/harness/codex/\`). 4. Project constraints. 5. Project decisions. 6. Verified guards. 7. Checkpoints. 8. Instincts. 9. Freeform notes. Full: \`openhermes/harness/rules/precedence.md\`.
-
-## Hygiene
-
-- Checkpoint on meaningful boundaries. Compress closed segments immediately.
-- After subagent return: verify → compress that block.
-- Compress proactively.
-- Skill candidates → \`/learn\` only if repeated pattern + \`ohc_search\` confirms no dup. See \`openhermes/harness/rules/skills-management.md\`.
-- Audit triggers: openhermes/config change, repeated failures, session start when last audit >7 days. See \`openhermes/harness/rules/audit.md\`.
-
-## Escalation
-
-T0: observe → log mistake → smallest fix. T1: add prevention rule → verify. T2: diagnosis/specialist → backlog. T3: constrained safe mode. Full: \`openhermes/harness/rules/self-heal.md\`.
-
-## State
-
-- **Config root**: \`%USERPROFILE%\\.config\\opencode\`
-- **Auth**: \`%USERPROFILE%\\.local\\share\\opencode\\auth.json\` (NEVER delete)
-- **Forensic ledger**: \`%USERPROFILE%\\.local\\share\\opencode\\opencode.db\``
-
-  return [
-    `<OPENHERMES_BOOTSTRAP>\nOpenHermes v${getOwnVersion()} active. Harness: \`openhermes/harness/\`. Memory at \`~/.local/share/opencode/openhermes/memory/\`. Rules at \`openhermes/harness/rules/\`. Skills discoverable via \`skill\` tool — use \`skill\` tool to list/load them.`,
-    `<OPENHERMES_CONSTITUTION>\n${constitution}\n</OPENHERMES_CONSTITUTION>`,
-    `<OPENHERMES_RUNTIME>\n${runtime}\n</OPENHERMES_RUNTIME>`,
-    `<OPENHERMES_ROUTER>\n${router}\n</OPENHERMES_ROUTER>`
-  ].join("\n\n")
-}
-
-const OWN_VERSION = (() => {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8")).version || "1.0.0"
-  } catch { return "1.0.0" }
-})()
-function getOwnVersion() { return OWN_VERSION }
-
-export const BootstrapPlugin = async ({ client, directory }) => {
-  let _bootstrapCache
-
-  const getContent = () => {
-    if (_bootstrapCache !== undefined) return _bootstrapCache
-    try {
-      _bootstrapCache = buildBootstrapContent()
-    } catch (err) {
-      console.error("[openhermes-bootstrap] failed to build bootstrap content:", err.message)
-      _bootstrapCache = null
-    }
-    return _bootstrapCache
-  }
-
-  return {
-    config: async (config) => {
-      config.skills = config.skills || {}
-      config.skills.paths = config.skills.paths || []
-      if (!config.skills.paths.includes(getSkillsDir())) {
-        config.skills.paths.push(getSkillsDir())
-      }
-
-      const PROMPTS_DIR = path.join(getHarnessDir(), "prompts")
-      const COMMANDS_DIR = path.join(getHarnessDir(), "commands")
-      const ct = (file) => {
-        const fp = path.join(COMMANDS_DIR, file)
-        try { return fs.readFileSync(fp, "utf8").trimEnd() + "\n\n$ARGUMENTS" }
-        catch { return "$ARGUMENTS" }
-      }
-      const p = (name) => {
-        const fp = path.join(PROMPTS_DIR, name)
-        try { return fs.readFileSync(fp, "utf8").trimEnd() }
-        catch { return "" }
-      }
-
-      const existingCommands = config.command ?? {}
-      const existingAgents = { ...(config.agent ?? {}) }
-
-      config.command = {
-        ...existingCommands,
-        "build-fix": { agent: "build-error-resolver", description: "Fix build and TypeScript errors", subtask: true, template: ct("build-fix.md") },
-        "code-review": { agent: "code-reviewer", description: "Review code for quality, security, and maintainability", subtask: true, template: ct("code-review.md") },
-        "plan": { agent: "planner", description: "Create a detailed implementation plan", subtask: true, template: ct("plan.md") },
-        "security": { agent: "security-reviewer", description: "Run comprehensive security review", subtask: true, template: ct("security.md") },
-        "doctor": { agent: "OpenHermes", description: "Run OpenCode OpenHermes health diagnostics", subtask: true, template: ct("doctor.md") },
-        "memory-search": { agent: "OpenHermes", description: "Search OpenHermes memory with LLM summarization", subtask: true, template: ct("memory-search.md") },
-        "learn": { agent: "OpenHermes", description: "Create a new skill from recent work patterns", subtask: true, template: ct("learn.md") },
-        "ohc": { template: "", description: "OHC context management: /ohc status, /ohc compress [focus]" },
-        "update-me": { template: "", description: "Force reinstall OpenHermes plugin from latest source" },
-        "orchestrate": { agent: "planner", description: "Orchestrate multiple agents for complex tasks", subtask: true, template: ct("orchestrate.md") },
-        "eval": { agent: "planner", description: "Evaluate implementation against acceptance criteria", subtask: true, template: ct("eval.md") },
-        "model-route": { agent: "OpenHermes", description: "Recommend model tier by task complexity and budget", subtask: true, template: ct("model-route.md") },
-        "quality-gate": { agent: "OpenHermes", description: "Run quality pipeline (format, lint, type check)", subtask: true, template: ct("quality-gate.md") },
-        "test-coverage": { agent: "tdd-guide", description: "Analyze coverage reports and identify gaps", subtask: true, template: ct("test-coverage.md") },
-        "update-docs": { agent: "doc-updater", description: "Update documentation for recent code changes", subtask: true, template: ct("update-docs.md") },
-        "update-codemaps": { agent: "doc-updater", description: "Generate/update architecture codemaps", subtask: true, template: ct("update-codemaps.md") },
-        "refactor-clean": { agent: "refactor-cleaner", description: "Remove dead code and consolidate duplicates", subtask: true, template: ct("refactor-clean.md") },
-        "verify": { agent: "OpenHermes", description: "Run comprehensive verification loop (typecheck, lint, test, build)", subtask: true, template: ct("verify.md") },
-        "checkpoint": { agent: "OpenHermes", description: "Save verification state and progress checkpoint", subtask: true, template: ct("checkpoint.md") },
-        "loop-start": { agent: "loop-operator", description: "Start managed autonomous loop with safety defaults", subtask: true, template: ct("loop-start.md") },
-        "loop-status": { agent: "OpenHermes", description: "Inspect active loop state, progress, and failure signals", subtask: true, template: ct("loop-status.md") },
-        "harness-audit": { agent: "harness-optimizer", description: "Run harness self-audit across 7 categories", subtask: true, template: ct("harness-audit.md") },
-        "setup-pm": { agent: "OpenHermes", description: "Configure package manager preference for the project", subtask: true, template: ct("setup-pm.md") },
-        "go-build": { agent: "build-go", description: "Fix Go build, vet, and compilation errors", subtask: true, template: ct("go-build.md") },
-        "go-review": { agent: "review-go", description: "Review Go code for idiomatic patterns and best practices", subtask: true, template: ct("go-review.md") },
-        "rust-build": { agent: "build-rust", description: "Fix Rust build, clippy, and dependency errors", subtask: true, template: ct("rust-build.md") },
-        "rust-review": { agent: "review-rust", description: "Review Rust code for safety, ownership, and idioms", subtask: true, template: ct("rust-review.md") },
-        "skill-create": { agent: "OpenHermes", description: "Generate a new skill from git history analysis", subtask: true, template: ct("skill-create.md") },
-      }
-
-      config.experimental ??= {}
-      config.experimental.primary_tools ??= []
-      if (!config.experimental.primary_tools.includes("compress")) {
-        config.experimental.primary_tools.push("compress")
-      }
-
-      config.agent = {
-        ...existingAgents,
-        "OpenHermes": {
-          description: "Fully autonomous primary coding agent (all tools allowed)",
-          mode: "primary",
-          color: "#F59E0B",
-          permission: {
-            bash: { "*": "allow" },
-            edit: "allow",
-            read: "allow",
-            task: { "*": "allow" },
-          },
-        },
-        "architect": {
-          description: "Software architecture specialist for system design",
-          mode: "subagent",
-          prompt: p("architect.txt"),
-          permission: { read: "allow", edit: "deny", bash: "deny" },
-        },
-        "build-error-resolver": {
-          description: "Build and TypeScript error resolution specialist",
-          mode: "subagent",
-          prompt: p("build-error-resolver.md"),
-          permission: { read: "allow", edit: "allow" },
-        },
-        "code-reviewer": {
-          description: "Expert code review specialist",
-          mode: "subagent",
-          prompt: p("code-reviewer.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny", task: { explore: "allow", "*": "deny" } },
-        },
-        "e2e-runner": {
-          description: "End-to-end testing specialist using Playwright",
-          mode: "subagent",
-          prompt: p("e2e-runner.txt"),
-          permission: { read: "allow", edit: "allow" },
-        },
-        "explore": {
-          description: "Fast read-only codebase exploration agent",
-          mode: "subagent",
-          prompt: p("explore.md"),
-          permission: { read: "allow", grep: "allow", glob: "allow", list: "allow", edit: "deny", bash: "deny" },
-        },
-        "planner": {
-          description: "Expert planning specialist for complex features and refactoring",
-          mode: "subagent",
-          color: "#3B82F6",
-          prompt: p("planner.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny" },
-        },
-        "security-reviewer": {
-          description: "Security vulnerability detection and remediation specialist",
-          mode: "subagent",
-          prompt: p("security-reviewer.md"),
-          permission: { read: "allow", edit: "deny", bash: "deny", task: { "*": "allow" } },
-        },
-        "docs-lookup": {
-          description: "Documentation lookup via MCP — query any library docs in real-time",
-          mode: "subagent",
-          prompt: p("docs-lookup.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "doc-updater": {
-          description: "Documentation and codemap generation/update specialist",
-          mode: "subagent",
-          prompt: p("doc-updater.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "refactor-cleaner": {
-          description: "Dead code detection and safe removal specialist",
-          mode: "subagent",
-          prompt: p("refactor-cleaner.md"),
-          permission: { read: "allow", edit: "allow" },
-        },
-        "loop-operator": {
-          description: "Autonomous agent loop operator — safe iteration with stop conditions",
-          mode: "subagent",
-          prompt: p("loop-operator.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow", task: { "*": "allow" } },
-        },
-        "harness-optimizer": {
-          description: "OpenHermes harness configuration optimizer — audit, tune, measure",
-          mode: "subagent",
-          prompt: p("harness-optimizer.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "tdd-guide": {
-          description: "Test-Driven Development coach — red-green-refactor cycle enforcement",
-          mode: "subagent",
-          prompt: p("tdd-guide.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "review-go": {
-          description: "Go code review specialist — idiomatic Go, concurrency, error handling",
-          mode: "subagent",
-          prompt: p("review-go.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "build-go": {
-          description: "Go build error resolution specialist — go build, vet, staticcheck fixes",
-          mode: "subagent",
-          prompt: p("build-go.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "review-database": {
-          description: "PostgreSQL database specialist — query optimization, schema, RLS, indexes",
-          mode: "subagent",
-          prompt: p("review-database.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "review-cpp": {
-          description: "C++ code review specialist — memory safety, modern C++, RAII",
-          mode: "subagent",
-          prompt: p("review-cpp.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "build-cpp": {
-          description: "C++ build error resolution specialist — CMake, linker, template errors",
-          mode: "subagent",
-          prompt: p("build-cpp.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "review-java": {
-          description: "Java/Spring Boot review specialist — JPA, architecture, security",
-          mode: "subagent",
-          prompt: p("review-java.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "build-java": {
-          description: "Java/Maven/Gradle build error resolution specialist",
-          mode: "subagent",
-          prompt: p("build-java.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "review-kotlin": {
-          description: "Kotlin/Android review specialist — coroutines, Compose, architecture",
-          mode: "subagent",
-          prompt: p("review-kotlin.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "build-kotlin": {
-          description: "Kotlin/Gradle build error resolution specialist",
-          mode: "subagent",
-          prompt: p("build-kotlin.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-        "review-python": {
-          description: "Python code review specialist — PEP 8, type hints, security",
-          mode: "subagent",
-          prompt: p("review-python.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "review-rust": {
-          description: "Rust code review specialist — ownership, lifetimes, safety",
-          mode: "subagent",
-          prompt: p("review-rust.md"),
-          permission: { read: "allow", bash: "allow", edit: "deny" },
-        },
-        "build-rust": {
-          description: "Rust build error resolution specialist — cargo, borrow checker, clippy",
-          mode: "subagent",
-          prompt: p("build-rust.md"),
-          permission: { read: "allow", edit: "allow", bash: "allow" },
-        },
-      }
-
-      config.default_agent = "OpenHermes"
-    },
-
-    "experimental.chat.messages.transform": async (_input, output) => {
-      try {
-        const bootstrap = getContent()
-        if (!bootstrap || !output.messages || !output.messages.length) return
-        const firstUser = output.messages.find(m => m && m.info && m.info.role === "user")
-        if (!firstUser || !firstUser.parts || !firstUser.parts.length) return
-        if (firstUser.parts.some(p => p.type === "text" && p.text.includes("OPENHERMES_BOOTSTRAP"))) return
-        const ref = firstUser.parts[0]
-        firstUser.parts.unshift({ ...ref, type: "text", text: bootstrap })
-      } catch (err) {
-        console.error("[openhermes-bootstrap] transform error:", err.message)
-      }
-    }
-  }
-}
+import path from "node:path"
+import fs from "node:fs"
+import { fileURLToPath } from "node:url"
+import { createLogger } from "./lib/logger.mjs"
+import { getHarnessDir, setHarnessRootForTest, resolveHarnessRoot } from "./lib/harness-resolver.mjs"
+
+const log = createLogger("bootstrap")
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const BOOTSTRAP_MARKER = "OPENHERMES_BOOTSTRAP"
+const OPENHERMES_AGENT = "OpenHermes"
+
+export { resolveHarnessRoot, setHarnessRootForTest, getHarnessDir }
+
+function parseFrontmatter(raw) {
+  const frontmatter = {}
+  if (!raw) return frontmatter
+  for (const line of raw.split(/\r?\n/)) {
+    const idx = line.indexOf(":")
+    if (idx < 0) continue
+    const key = line.slice(0, idx).trim()
+    const value = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, "")
+    if (key) frontmatter[key] = value
+  }
+  return frontmatter
+}
+
+function readMarkdownDocument(filePath) {
+  if (!fs.existsSync(filePath)) return null
+  const source = fs.readFileSync(filePath, "utf8")
+  const match = source.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  const frontmatter = parseFrontmatter(match?.[1] ?? "")
+  const body = (match ? match[2] : source).trim()
+  return { frontmatter, body }
+}
+
+function readMarkdownDirectory(dir) {
+  if (!fs.existsSync(dir)) return []
+  return fs.readdirSync(dir)
+    .filter(name => name.endsWith(".md") && name.toLowerCase() !== "readme.md")
+    .sort((a, b) => a.localeCompare(b))
+    .map(name => {
+      const filePath = path.join(dir, name)
+      const document = readMarkdownDocument(filePath)
+      return document ? { name: path.basename(name, ".md"), ...document } : null
+    })
+    .filter(Boolean)
+}
+
+function commandDefinitions(dir) {
+  const commands = {}
+  for (const doc of readMarkdownDirectory(dir)) {
+    const command = {
+      description: doc.frontmatter.description || `OpenHermes command ${doc.name}`,
+      template: doc.body,
+    }
+    if (doc.frontmatter.agent) command.agent = doc.frontmatter.agent
+    if (doc.frontmatter.model) command.model = doc.frontmatter.model
+    if (doc.frontmatter.subtask) command.subtask = doc.frontmatter.subtask === "true"
+    commands[doc.name] = command
+  }
+  return commands
+}
+
+function agentDefinitions(dir) {
+  const agents = {}
+  for (const doc of readMarkdownDirectory(dir)) {
+    const name = doc.name === "openhermes" ? OPENHERMES_AGENT : doc.name
+    agents[name] = {
+      description: doc.frontmatter.description || (name === OPENHERMES_AGENT ? "OpenHermes primary orchestrator" : `OpenHermes agent ${name}`),
+      mode: doc.frontmatter.mode || (name === OPENHERMES_AGENT ? "primary" : "subagent"),
+      prompt: doc.body,
+    }
+  }
+  return agents
+}
+
+function uniqueStrings(existing = [], additions = []) {
+  const seen = new Set(existing.filter(Boolean))
+  const merged = [...existing]
+  for (const item of additions) {
+    if (!item || seen.has(item)) continue
+    seen.add(item)
+    merged.push(item)
+  }
+  return merged
+}
+
+function readText(filePath) {
+  return fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : ""
+}
+
+function buildBootstrapContent(hDir) {
+  const parts = [
+    `<${BOOTSTRAP_MARKER}>`,
+    `You are OpenHermes.`,
+    `OpenHermes is OpenCode-native: load skills on demand, prefer subagents for substantive work, and keep the surface small.`,
+    `Durable state is removed for now. Do not invent a persistence layer unless the user explicitly asks for one later.`,
+  ]
+
+  const constitution = readText(path.join(hDir, "codex", "CONSTITUTION.md"))
+  const runtime = readText(path.join(hDir, "instructions", "RUNTIME.md"))
+  const context = readText(path.join(__dirname, "CONTEXT.md"))
+  const ethos = readText(path.join(__dirname, "ETHOS.md"))
+
+  if (constitution) parts.push(`<CONSTITUTION>\n${constitution}\n</CONSTITUTION>`)
+  if (runtime) parts.push(`<RUNTIME>\n${runtime}\n</RUNTIME>`)
+  if (context) parts.push(`<CONTEXT>\n${context}\n</CONTEXT>`)
+  if (ethos) parts.push(`<ETHOS>\n${ethos}\n</ETHOS>`)
+  parts.push(`</${BOOTSTRAP_MARKER}>`)
+
+  return parts.join("\n\n")
+}
+
+export const BootstrapPlugin = async () => {
+  const hDir = getHarnessDir()
+  const skillsDir = path.join(hDir, "skills")
+  const commandsDir = path.join(hDir, "commands")
+  const agentsDir = path.join(hDir, "agents")
+  const bootstrapContent = buildBootstrapContent(hDir)
+
+  return {
+    config: async (config) => {
+      config.skills = config.skills || {}
+      config.skills.paths = uniqueStrings(config.skills.paths || [], [skillsDir])
+
+      config.command = { ...(config.command ?? {}), ...commandDefinitions(commandsDir) }
+
+      const loadedAgents = agentDefinitions(agentsDir)
+      const openHermesAgent = loadedAgents[OPENHERMES_AGENT] ?? {
+        description: "OpenHermes primary orchestrator",
+        mode: "primary",
+        prompt: "You are OpenHermes.",
+      }
+
+      config.agent = {
+        ...(config.agent ?? {}),
+        ...loadedAgents,
+        [OPENHERMES_AGENT]: {
+          ...openHermesAgent,
+          description: openHermesAgent.description || "OpenHermes primary orchestrator",
+          mode: "primary",
+          permission: {
+            bash: { "*": "allow" },
+            edit: "allow",
+            read: "allow",
+            task: { "*": "allow" },
+          },
+        },
+      }
+
+      config.default_agent = OPENHERMES_AGENT
+
+      config.instructions = uniqueStrings(config.instructions || [], [
+        path.join(hDir, "codex", "CONSTITUTION.md"),
+        path.join(hDir, "instructions", "RUNTIME.md"),
+        path.join(__dirname, "CONTEXT.md"),
+        path.join(__dirname, "ETHOS.md"),
+      ])
+    },
+
+    "experimental.chat.messages.transform": async (_input, output) => {
+      try {
+        if (!output.messages?.length) return
+        const firstUser = output.messages.find(m => m?.info?.role === "user")
+        if (!firstUser?.parts?.length) return
+        if (firstUser.parts.some(p => p.text?.includes(BOOTSTRAP_MARKER))) return
+        const ref = firstUser.parts[0]
+        firstUser.parts.unshift({ ...ref, type: "text", text: bootstrapContent })
+      } catch (err) {
+        log.error("transform error:", err?.message)
+      }
+    },
+  }
+}