@jairodri/huckleberry-cli 1.0.1 → 1.1.0

package/src/harness/registry.js

@@ -0,0 +1,121 @@
+/**
+ * registry — adapter registry + selection policy.
+ *
+ * Selection policy (Phase 1):
+ *   1. Explicit `task.preferred` wins if that adapter is ready.
+ *   2. Capability-matched: tasks requiring tools/files go to tool-capable adapters.
+ *   3. Cost-optimized: among ready adapters that satisfy capabilities, pick the
+ *      lowest blended cost per task (local opencode = $0 API cost, so it usually
+ *      wins on cost; DeepSeek wins when opencode is unavailable or policy pins it).
+ *
+ * The persisted default lives in ~/.huckleberry/harness.json ("default": "<id>").
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { OpenCodeAdapter } from "./opencode-adapter.js";
+import { DeepSeekAdapter } from "./deepseek-adapter.js";
+import { PiAdapter } from "./pi-adapter.js";
+
+/** @type {Map<string, import("./types.js").HarnessAdapter>} */
+const adapters = new Map();
+
+export function register(adapter) {
+  adapters.set(adapter.id, adapter);
+}
+
+/** Built-in adapters, registered once at import. */
+register(new OpenCodeAdapter());
+register(new DeepSeekAdapter());
+register(new PiAdapter());
+
+/** @returns {string[]} registered adapter ids in registration order */
+export function listIds() {
+  return [...adapters.keys()];
+}
+
+export function get(id) {
+  return adapters.get(id) || null;
+}
+
+/**
+ * Read the persisted default adapter id.
+ * @param {string} [home] state root (defaults to process HOME / sandbox HOME via caller)
+ * @returns {string|null}
+ */
+export function loadDefault(home) {
+  const p = harnessConfigPath(home);
+  if (!existsSync(p)) return null;
+  try {
+    const j = JSON.parse(readFileSync(p, "utf8"));
+    return j.default || null;
+  } catch { return null; }
+}
+
+/**
+ * Persist the default adapter id.
+ * @param {string} id
+ * @param {string} [home]
+ */
+export function saveDefault(id, home) {
+  if (!adapters.has(id)) throw new Error(`unknown adapter: ${id} (available: ${listIds().join(", ")})`);
+  const p = harnessConfigPath(home);
+  mkdirSync(dirname(p), { recursive: true });
+  writeFileSync(p, JSON.stringify({ default: id, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+export function harnessConfigPath(home) {
+  const h = home || process.env.HUCKLEBERRY_HOME || process.env.HOME || "";
+  return join(h, ".huckleberry", "harness.json");
+}
+
+/**
+ * Selection policy. See module doc for the ordering.
+ * @param {import("./types.js").TaskRequest & {preferred?:string}} task
+ * @param {string|null} [defaultId] persisted default (harness.json)
+ * @returns {Promise<{adapter: import("./types.js").HarnessAdapter, why: string}>}
+ */
+export async function selectAdapter(task = {}, defaultId = null) {
+  const candidates = [];
+  // 1. explicit preference
+  if (task.preferred && adapters.has(task.preferred)) candidates.push([task.preferred, "explicit task preference"]);
+  if (defaultId && adapters.has(defaultId)) candidates.push([defaultId, "persisted default (harness set)"]);
+  // fallback order: cost-optimized (deepseek), then lean local agent (pi), then local default
+  candidates.push(["deepseek", "cost-optimized fallback"]);
+  candidates.push(["pi", "lean cold-start fallback"]);
+  candidates.push(["opencode", "local default fallback"]);
+
+  const needTools = task.requireTools === true;
+  for (const [id, why] of candidates) {
+    const a = adapters.get(id);
+    if (!a) continue;
+    const caps = a.capabilities();
+    if (needTools && !caps.tools) continue; // capability-matched gate
+    const st = await a.status();
+    if (st.ready) return { adapter: a, why };
+  }
+  throw new Error("no ready adapter — install opencode or set DEEPSEEK_API_KEY");
+}
+
+/**
+ * Table row data for `huckleberry harness list`.
+ * @param {string} [home]
+ */
+export async function describeAdapters(home) {
+  const defaultId = loadDefault(home);
+  const rows = [];
+  for (const id of listIds()) {
+    const a = adapters.get(id);
+    const st = await a.status();
+    const caps = a.capabilities();
+    rows.push({
+      id,
+      label: a.label,
+      ready: st.ready,
+      reason: st.reason || null,
+      detail: st.detail || null,
+      caps,
+      isDefault: id === defaultId,
+    });
+  }
+  return { rows, defaultId };
+}

package/src/harness/telemetry.js

@@ -0,0 +1,102 @@
+/**
+ * Telemetry — per-task token + cost recording as JSON lines.
+ *
+ * One JSONL file per harness run: tests/baseline/telemetry-<runId>.jsonl
+ * Each line: { ts, runId, taskId, adapterId, model, status, usage, costUsd, durationMs }
+ * Append-only; a run summary is written next to it on close (see writeSummary).
+ */
+import { appendFileSync, writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+
+export class Telemetry {
+  /**
+   * @param {string} filePath absolute path of the JSONL output
+   * @param {string} runId
+   */
+  constructor(filePath, runId) {
+    this.filePath = filePath;
+    this.runId = runId;
+    this.records = [];
+    mkdirSync(dirname(filePath), { recursive: true });
+    // header line makes each file self-describing
+    appendFileSync(filePath, JSON.stringify({
+      ts: new Date().toISOString(),
+      runId,
+      event: "run-start",
+    }) + "\n");
+  }
+
+  /**
+   * Record one task result.
+   * @param {{taskId:string, adapterId:string, model?:string, status:string,
+   *          usage:{input:number, output:number, cacheHit?:number, cacheMiss?:number},
+   *          costUsd:number, durationMs:number, error?:string}} r
+   */
+  record(r) {
+    const line = {
+      ts: new Date().toISOString(),
+      runId: this.runId,
+      taskId: r.taskId,
+      adapterId: r.adapterId,
+      model: r.model || null,
+      status: r.status,
+      usage: {
+        input: r.usage?.input || 0,
+        output: r.usage?.output || 0,
+        cacheHit: r.usage?.cacheHit ?? null,
+        cacheMiss: r.usage?.cacheMiss ?? null,
+      },
+      costUsd: Math.round((r.costUsd || 0) * 1e6) / 1e6,
+      durationMs: r.durationMs || 0,
+    };
+    if (r.error) line.error = r.error;
+    this.records.push(line);
+    appendFileSync(this.filePath, JSON.stringify(line) + "\n");
+  }
+
+  /**
+   * Write a run summary JSON alongside the JSONL and return it.
+   * @returns {{runId:string, telemetryFile:string, tasks:number, ok:number, failed:number,
+   *            tokensIn:number, tokensOut:number, costUsd:number, byAdapter:Object}}
+   */
+  writeSummary() {
+    const byAdapter = {};
+    for (const r of this.records) {
+      const a = (byAdapter[r.adapterId] ||= { tasks: 0, ok: 0, failed: 0, tokensIn: 0, tokensOut: 0, costUsd: 0 });
+      a.tasks++;
+      if (r.status === "ok") a.ok++; else a.failed++;
+      a.tokensIn += r.usage.input;
+      a.tokensOut += r.usage.output;
+      a.costUsd = Math.round((a.costUsd + r.costUsd) * 1e6) / 1e6;
+    }
+    const summary = {
+      runId: this.runId,
+      finishedAt: new Date().toISOString(),
+      telemetryFile: this.filePath,
+      tasks: this.records.length,
+      ok: this.records.filter(r => r.status === "ok").length,
+      failed: this.records.filter(r => r.status !== "ok").length,
+      tokensIn: this.records.reduce((s, r) => s + r.usage.input, 0),
+      tokensOut: this.records.reduce((s, r) => s + r.usage.output, 0),
+      costUsd: Math.round(this.records.reduce((s, r) => s + r.costUsd, 0) * 1e6) / 1e6,
+      byAdapter,
+    };
+    const summaryPath = this.filePath.replace(/\.jsonl$/, "-summary.json");
+    writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+    return summary;
+  }
+}
+
+/**
+ * Read back a telemetry JSONL file (used by comparison tooling).
+ * @param {string} filePath
+ * @returns {Array<Object>}
+ */
+export function readTelemetry(filePath) {
+  if (!existsSync(filePath)) return [];
+  return readFileSync(filePath, "utf8")
+    .split("\n")
+    .filter(l => l.trim())
+    .map(l => { try { return JSON.parse(l); } catch { return null; } })
+    .filter(Boolean);
+}

package/src/harness/types.js

@@ -0,0 +1,165 @@
+/**
+ * HarnessAdapter — the contract every execution harness implements.
+ *
+ * A "harness" is the thing that actually runs an agent task: the default is the
+ * local `opencode` CLI (existing behavior); alternatives route the same task to a
+ * different engine (e.g. the DeepSeek API) so cost/capability can be traded off
+ * per task. The interface is deliberately plain JSDoc so the repo stays build-free.
+ *
+ * Implementations live alongside this file (`opencode-adapter.js`,
+ * `deepseek-adapter.js`) and are registered in `registry.js`.
+ *
+ * @typedef {Object} TaskRequest
+ * @property {string} id            Stable task id (e.g. golden task id).
+ * @property {string} prompt        The instruction to run.
+ * @property {string} [cwd]         Working directory the task should operate in.
+ * @property {string} [agent]       Named agent for engines that support it (opencode).
+ * @property {string} [model]       Model id override.
+ * @property {number} [maxTokens]   Output token cap.
+ * @property {string} [system]      Optional system prompt.
+ * @property {Record<string,string>} [meta] Free-form task metadata (tenant, client…).
+ *
+ * @typedef {Object} TaskResult
+ * @property {string}  taskId          Which task ran.
+ * @property {string}  adapterId       Which harness produced it.
+ * @property {"ok"|"error"|"cancelled"} status
+ * @property {string}  output          Final text output.
+ * @property {string}  [error]         Error message when status!=="ok".
+ * @property {string}  [stderr]        Diagnostic stderr (non-fatal engine log noise).
+ * @property {TokenUsage} usage
+ * @property {number}  costUsd         Estimated cost in USD.
+ * @property {number}  durationMs
+ * @property {string}  startedAt       ISO timestamp.
+ * @property {string}  [checkpointId]  Resume handle when supported.
+ * @property {string[]} [files]        Files produced by the task.
+ *
+ * @typedef {Object} TokenUsage
+ * @property {number} input
+ * @property {number} output
+ * @property {number} [cacheHit]      Input tokens served from cache.
+ * @property {number} [cacheMiss]     Input tokens billed at full rate.
+ *
+ * @typedef {Object} Capabilities
+ * @property {boolean} streaming      Yields incremental output.
+ * @property {boolean} checkpoint     Can snapshot/resume a run.
+ * @property {boolean} cancel         Can abort an in-flight run.
+ * @property {boolean} files          Can return produced files.
+ * @property {boolean} tools          Runs tools / filesystem access.
+ * @property {boolean} modelChoice    Supports per-call model selection.
+ * @property {number}  costPerMTokIn  Rough blended input price (USD / 1M tok).
+ * @property {number}  costPerMTokOut Rough blended output price (USD / 1M tok).
+ *
+ * @typedef {Object} AdapterStatus
+ * @property {boolean} ready
+ * @property {string}  [reason]       Why not ready (e.g. missing credential).
+ * @property {string}  [detail]
+ */
+
+/**
+ * Marker base class. Adapters may extend it or merely satisfy the shape.
+ * Every method documented here is REQUIRED unless marked optional.
+ */
+export class HarnessAdapter {
+  /** @param {Object} [opts] */
+  constructor(opts = {}) {
+    this.id = opts.id || "unnamed";
+    this.label = opts.label || this.id;
+  }
+
+  /** @returns {Capabilities} */
+  capabilities() {
+    throw new Error(`${this.id}: capabilities() not implemented`);
+  }
+
+  /** @returns {Promise<AdapterStatus>} readiness probe (creds, binaries, network) */
+  async status() {
+    throw new Error(`${this.id}: status() not implemented`);
+  }
+
+  /**
+   * Run a task to completion. REQUIRED.
+   * @param {TaskRequest} task
+   * @returns {Promise<TaskResult>}
+   */
+  async submit(_task) {
+    throw new Error(`${this.id}: submit() not implemented`);
+  }
+
+  /**
+   * Incremental output. OPTIONAL — callers fall back to submit() output.
+   * @param {TaskRequest} task
+   * @returns {AsyncIterable<string>}
+   */
+  async *stream(_task) {
+    throw new Error(`${this.id}: stream() not implemented`);
+  }
+
+  /**
+   * Snapshot an in-flight task so it can resume later. OPTIONAL.
+   * @param {string} _taskId
+   * @returns {Promise<string|null>} checkpoint id, or null if unsupported
+   */
+  async checkpoint(_taskId) {
+    return null;
+  }
+
+  /**
+   * Resume from a checkpoint id. OPTIONAL.
+   * @param {string} _checkpointId
+   * @returns {Promise<TaskResult>}
+   */
+  async resume(_checkpointId) {
+    throw new Error(`${this.id}: resume() not implemented`);
+  }
+
+  /**
+   * Cancel an in-flight task. OPTIONAL.
+   * @param {string} _taskId
+   * @returns {Promise<boolean>} true if a run was cancelled
+   */
+  async cancel(_taskId) {
+    return false;
+  }
+
+  /**
+   * Return files produced by a task. OPTIONAL.
+   * @param {string} _taskId
+   * @returns {Promise<string[]>} absolute paths
+   */
+  async downloadFiles(_taskId) {
+    return [];
+  }
+}
+
+/** @returns {string} ISO timestamp helper */
+export function nowIso() {
+  return new Date().toISOString();
+}
+
+/**
+ * Round a USD cost to 6 decimal places (sub-cent precision, stable JSON output).
+ * @param {number} n
+ * @returns {number}
+ */
+export function roundCost(n) {
+  return Math.round((Number.isFinite(n) ? n : 0) * 1e6) / 1e6;
+}
+
+/**
+ * Build a zeroed TaskResult with sane defaults, so adapters only fill what differs.
+ * @param {TaskRequest & {adapterId: string}} t
+ * @returns {TaskResult}
+ */
+export function baseResult(t) {
+  return {
+    taskId: t.id,
+    adapterId: t.adapterId,
+    status: "ok",
+    output: "",
+    usage: { input: 0, output: 0 },
+    costUsd: 0,
+    durationMs: 0,
+    startedAt: nowIso(),
+    files: [],
+  };
+}

package/src/interview.js

@@ -1,8 +1,10 @@
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 import { createInterface } from "node:readline";
 
-const HB_DIR = join(process.env.HOME || process.env.USERPROFILE, ".huckleberry");
+const HOME = homedir();
+const HB_DIR = join(HOME, ".huckleberry");
 
 function ask(rl, question) {
   return new Promise((resolve) => {
@@ -11,9 +13,9 @@ function ask(rl, question) {
 }
 
 export async function runInterview() {
-  console.log(`\n  ╔══════════════════════════════════════════════════════════╗`);
-  console.log(`  ║           HUCKLEBERRY — First Run Setup                 ║`);
-  console.log(`  ╚══════════════════════════════════════════════════════════╝`);
+  console.log(`\n  ╔════════════════════════════════════════════════════════════╗`);
+  console.log(`  ║           HUCKLEBERRY — First Run Setup                    ║`);
+  console.log(`  ╚════════════════════════════════════════════════════════════╝`);
   console.log(`\n  I'll ask a few questions to set up your AI system.\n`);
 
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -32,6 +34,10 @@ export async function runInterview() {
 
   console.log(`\n  Help areas (comma-separated): outreach, content, research, social, seo, marketing, ops, all`);
   answers.priorities = await ask(rl, ">");
+
+  console.log(`\n  Optional keys (press Enter to skip — you can add them later in ~/.huckleberry/.env):`);
+  answers.typesafeKey = await ask(rl, "TypeSafe Jev API key (typesafe.ai)?");
+  answers.discordToken = await ask(rl, "Discord bot token?");
   rl.close();
 
   writeFileSync(join(HB_DIR, "USER.md"), [
@@ -73,6 +79,32 @@ export async function runInterview() {
     }
   }
 
+  // Write provided keys into ~/.huckleberry/.env (never overwrite existing values)
+  const envFile = join(HB_DIR, ".env");
+  let env = existsSync(envFile) ? readFileSync(envFile, "utf-8") : "DISCORD_BOT_TOKEN=\nTYPESAFE_API_KEY=\n";
+  const setIfEmpty = (key, val) => {
+    if (!val) return;
+    const re = new RegExp(`^${key}=.*$`, "m");
+    env = re.test(env) ? env.replace(re, `${key}=${val}`) : `${env}${key}=${val}\n`;
+  };
+  setIfEmpty("TYPESAFE_API_KEY", answers.typesafeKey);
+  setIfEmpty("DISCORD_BOT_TOKEN", answers.discordToken);
+  writeFileSync(envFile, env, "utf-8");
+
+  // Patch the Jev MCP env in ~/.opencode/opencode.json so judgment tools work out of the box
+  if (answers.typesafeKey) {
+    const ocFile = join(HOME, ".opencode", "opencode.json");
+    if (existsSync(ocFile)) {
+      try {
+        const cfg = JSON.parse(readFileSync(ocFile, "utf-8"));
+        if (cfg.mcp?.jev?.environment) cfg.mcp.jev.environment.TYPESAFE_API_KEY = answers.typesafeKey;
+        writeFileSync(ocFile, JSON.stringify(cfg, null, 2));
+      } catch { /* leave config untouched if invalid */ }
+    }
+  }
+
   console.log(`\n  ✓ USER.md, evergreen.md, SOUL.md, IDENTITY.md generated`);
+  if (answers.typesafeKey) console.log(`  ✓ Jev judgment layer configured`);
+  if (answers.discordToken) console.log(`  ✓ Discord token saved to ~/.huckleberry/.env (see ~/.huckleberry/wiki/discord.md to finish wiring)`);
   console.log(`  Next: type 'opencode' to start with your COS.\n`);
 }

package/src/postinstall.js

@@ -1,22 +1,20 @@
-// Post-install script: runs after npm install -g @huckleberry/cli
-// Prints next steps for the user
-
+// Post-install banner — runs after npm install -g @jairodri/huckleberry-cli
 console.log(`
-  ╔══════════════════════════════════════════════════════════╗
-  ║           HUCKLEBERRY AI SYSTEM INSTALLED               ║
-  ╚══════════════════════════════════════════════════════════╝
-
+  ╔════════════════════════════════════════════════════════════╗
+  ║           HUCKLEBERRY AI SYSTEM INSTALLED                  ║
+  ╚════════════════════════════════════════════════════════════╝
   Get started:
     1. huckleberry install        — set up the system
     2. npm install -g opencode    — install opencode
     3. npm install -g kimaki      — install kimaki
     4. huckleberry interview      — configure your agent
-
   Commands:
     huckleberry help              — show all commands
+    huckleberry doctor            — health check (run when anything feels off)
+    huckleberry packs             — list skill packs
+    huckleberry install-pack all  — deploy every skill pack
+    huckleberry cro <url>         — CRO audit of a landing page
+    huckleberry review            — weekly self-improvement review
     huckleberry update            — update to latest version
-    huckleberry install-pack      — add agent packs
-
-  Documentation:
-    https://huckleberry.ai/docs
+  Documentation: https://huckleberry.ai
 `);

package/templates/AGENTS.md

@@ -1,16 +1,23 @@
 # AGENTS.md — Workspace Rules & Protocols
 
 ## STARTUP RITUAL (MANDATORY)
+**Bootstrap context files (VERIFY, do not assume injection):**
+At session start, check whether your context already contains SOUL.md, USER.md, IDENTITY.md, COS_PROTOCOLS.md, TOOLS.md, and HEARTBEAT.md content (workspace root or your agent workspace). **If NOT present, read them yourself before doing any work.** These files define who you are, who the user is, your operating principles, and available tools. Operating without them = protocol breach. Never claim context you don't have, and never skip them because "bootstrap should have injected them."
+
 BEFORE responding to any message:
-1. Run Inkstone pre-injection: `inkstone_memory_failures()` + `inkstone_memory_search(query, namespace, limit=5)`
-2. Read `memory/YYYY-MM-DD.md` for today
-3. Read `.huckleberry/taskmaster/tasks/tasks.json` — what's active
-4. Read memory/corrections.md — active corrections
+1. Read `memory/YYYY-MM-DD.md` for today
+2. Read `.huckleberry/taskmaster/tasks/tasks.json` — what's active
+3. Read memory/corrections.md — active corrections
+
+## Inkstone Memory Tools
+Inkstone holds 25K+ structured decisions, preferences, procedures, contacts, failures. Boot context is auto-injected by the plugin on startup.
 
-## Inkstone Pre-Injection (MANDATORY)
-**Before any task:** run `inkstone_memory_failures()` + `inkstone_memory_search()`.
-If you see `[dedup:ref sha=...]` from any tool, the precheck hasn't been done yet — run it now.
-Soft dependency: if Inkstone MCP is down, skip and proceed.
+Routing by task:
+- Decision / preference / procedure → `inkstone_memory_search(query, namespace, limit=5)`
+- Repeating a past mistake → `inkstone_memory_failures()`
+- Broad archive / historical → `inkstone_memory_hybrid_answer` / `inkstone_memory_deep_query`
+
+Soft dependency: if Inkstone MCP is down, skip and proceed. Do NOT block or loop.
 
 ## COS Operations
 - You are the Chief of Staff — an orchestrator, not a worker
@@ -60,13 +67,6 @@ Before responding to business tasks, read `evergreen.md` to know the business.
 - When blocked after 2 attempts, report: what tried, what failed, what's next
 - Prefer finished work over status updates
 
-## Huckleberry MCP (when available)
-- `huckleberry_packs_list` — check available packs
-- `huckleberry_pack_install` — download and configure
-- `huckleberry_combos_check` — latest model combos
-- `huckleberry_update_check` — check for updates
-- `huckleberry_ideas_generate` — strategy suggestions
-
 ## Memory System
 - Write immediately when insight happens — not at session end
 - Source every claim: `(source: session X)` or `(source: user directive, YYYY-MM-DD)`
@@ -86,5 +86,5 @@ Before responding to business tasks, read `evergreen.md` to know the business.
 
 ## Kanban Workflows (optional)
 - Templates in `.huckleberry/kanban/templates/`
-- List: `bun src/cli.mjs templates` (if kanban sourcedir exists)
-- Stamp: `bun src/cli.mjs stamp <template> --var key=val`
+- List: `bun ~/.huckleberry/kanban/src/cli.mjs templates` (if kanban sourcedir exists)
+- Stamp: `bun ~/.huckleberry/kanban/src/cli.mjs stamp <template> --var key=val`

package/templates/ORG.md

@@ -26,7 +26,7 @@
 ~/.opencode/
 ├── opencode.json              # Main config
 ├── plugin/env-inject.ts       # .env auto-loader
-├── plugin/inkstone-gate.ts    # Pre-injection gate
+├── plugin/inkstone-priority.ts # Inkstone boot-context injection (no gate)
 └── mcp/                       # MCP server files
 
 ~/.claude/skills/              # Installed skills

package/templates/TOOLS.md

@@ -16,8 +16,13 @@
 | Command | Purpose |
 |---------|---------|
 | `huckleberry install` | Install Huckleberry system |
+| `huckleberry interview` | Personalize agents (name, business, keys) |
+| `huckleberry doctor` | Health check — run when anything feels off |
+| `huckleberry packs` | List available skill packs |
+| `huckleberry install-pack <name>` | Deploy a skill pack (core, doctor, content, cro, web-design, research, outreach-sales, social, self-improvement, all) |
+| `huckleberry cro <url>` | CRO audit of a landing page |
+| `huckleberry review` | Weekly self-improvement review (proposals only) |
 | `huckleberry update` | Update to latest version |
-| `huckleberry install-pack <name>` | Install agent/skill pack |
 | `huckleberry version` | Show version |
 
 ## Inkstone (Memory)
@@ -63,4 +68,4 @@
 |--------|---------|
 | Inkstone MCP | Memory search, write, dream cycle, graph |
 | Context7 MCP | Documentation lookup for libraries/tools |
-| Gemini Codegen MCP | Free code generation via Gemini |
+| Jev MCP | Fast judgment tools (classify, rerank, verify, gate) |

package/templates/opencode.json

@@ -1,5 +1,16 @@
 {
   "$schema": "https://opencode.ai/config.json",
+  "harness-policy": {
+    "default": "opencode",
+    "selection": "capability-matched, then cost-optimized",
+    "rules": {
+      "toolsRequired": "opencode",
+      "costOptimized": "deepseek",
+      "requireApprovalAboveCostUsd": 5,
+      "requireApprovalAboveTokens": 50000,
+      "escalateOnConsecutiveFailures": 2
+    }
+  },
   "mcp": {
     "inkstone": {
       "type": "local",
@@ -14,27 +25,23 @@
     },
     "context7": {
       "type": "local",
-      "command": ["npx", "-y", "@context7/server"],
+      "command": [
+        "npx",
+        "-y",
+        "@context7/server"
+      ],
       "enabled": true
     },
-    "gemini_codegen": {
+    "jev": {
       "type": "local",
       "command": [
         "node",
-        "{{USERPROFILE}}/.opencode/mcp/gemini-codegen-server.mjs"
+        "{{USERPROFILE}}/.huckleberry/mcp/jev-mcp/node_modules/@jkudish/jev-mcp/dist/index.js"
       ],
       "enabled": true,
       "environment": {
-        "GEMINI_API_KEY": ""
+        "TYPESAFE_API_KEY": ""
       }
-    },
-    "huckleberry": {
-      "type": "local",
-      "command": [
-        "huckleberry",
-        "mcp"
-      ],
-      "enabled": true
     }
   },
   "permission": {
@@ -42,8 +49,7 @@
   },
   "plugin": [
     "./plugin/env-inject.ts",
-    "./plugin/inkstone-gate.ts",
-    "context-mode"
+    "./plugin/inkstone-gate.ts"
   ],
   "compaction": {
     "mode": "safeguard",
@@ -52,29 +58,20 @@
   },
   "agent": {
     "build": {
-      "description": "Default executor. Runs tools, writes files, completes tasks.",
-      "mode": "primary",
-      "model": "omniroute/combo/freellmapi smart models"
+      "description": "Default executor. Runs tools, writes files, completes tasks."
     },
     "plan": {
-      "description": "Read-only strategy and analysis. Research tasks only.",
-      "mode": "primary",
-      "model": "omniroute/combo/freellmapi smart models"
+      "description": "Read-only strategy and analysis. Research tasks only."
     },
     "researcher": {
-      "description": "Web research, intelligence gathering, competitive analysis.",
-      "mode": "primary",
-      "model": "omniroute/combo/freellmapi smart models"
+      "description": "Web research, intelligence gathering, competitive analysis."
     },
     "hermes": {
-      "description": "System administrator. Troubleshoots and repairs the Huckleberry stack.",
-      "model": "omniroute/combo/freellmapi smart models",
-      "instructions": [
-        "./instructions/hermes.md"
-      ]
+      "description": "System administrator. Diagnoses and repairs the Huckleberry stack (kimaki, Discord, opencode, Inkstone, Jev).",
+      "prompt": "You are Hermes, the Huckleberry system administrator. At session start, BEFORE any work, read: ~/.huckleberry/agents/hermes/SOUL.md, ~/.huckleberry/agents/hermes/AGENTS.md, ~/.huckleberry/agents/hermes/hermes-fixer.md, and the wiki files in ~/.huckleberry/wiki/ (kimaki.md, discord.md, opencode.md, inkstone.md, doctor.md). When something breaks: diagnose first (or run `huckleberry doctor`), fix the root cause, verify every fix with a live test, and never print secret values. Escalate after 3 real failed attempts with what you tried, exact errors, and your recommended next step."
     }
   },
   "instructions": [
-    "./instructions/business-context-gate.md"
+    "{{USERPROFILE}}/.huckleberry/business-context-gate.md"
   ]
 }