lynkr 9.14.2 → 9.14.3

package/README.md

@@ -45,7 +45,7 @@ lynkr wrap claude
 - ✅ Sticky sessions: one routing decision per conversation via content fingerprinting, with automatic escalation when the task outgrows the model
 - ✅ TOON/RTK compression (84% token reduction on large JSON tool outputs)
 - ✅ Semantic caching (sub-300ms cache hits, 0 tokens billed)
-- ✅ **3-5x more usage from the same subscription limits**
+- ✅ **Your subscription is used only where it counts** — simple requests route to your own local/API models, so subscription capacity goes to the work that needs it
 - ✅ Works with OAuth (Claude, Copilot, Cursor) or API keys (Aider, Codex)
 
 [Full wrap guide →](docs/wrap-guide.md)
@@ -221,6 +221,7 @@ Claude Code / Cursor / Codex / Cline / Continue
 | **Z.ai** | Cloud | GLM-4.7, GLM-4.5-Air | $ |
 | **Moonshot AI** | Cloud | Kimi K2.6, Kimi K3 | $ |
 | **Baidu Qianfan** | Cloud | ERNIE 4.5 Turbo, ERNIE X1.1 | $ (unverified — not yet probed against a live key) |
+| **Fireworks AI** | Cloud | Kimi K2, GLM-5, DeepSeek V3 (serverless) | $ (unverified — not yet probed against a live key) |
 
 **4 local providers** for 100% offline, free usage. **14+ cloud providers** for scale.
 
@@ -617,6 +618,9 @@ With tier routing + token optimization: **additional 50-87% savings** on cloud p
 - [NPM Package](https://www.npmjs.com/package/lynkr) — Official releases
 - [DeepWiki](https://deepwiki.com/Fast-Editor/Lynkr) — AI-powered docs
 
+This project follows our [Code of Conduct](CODE_OF_CONDUCT.md) — it applies in
+all project spaces, and it tells you exactly how to report a problem.
+
 ---
 
 ## License

package/bin/cli.js

@@ -6,12 +6,15 @@ const pkg = require('../package.json');
 // Subcommands. Dispatched before server boot so `lynkr usage` / `lynkr trajectory`
 // don't start the proxy. Add new subcommands here, not in scattered binaries.
 const SUBCOMMANDS = {
-  usage:      path.join(__dirname, "lynkr-usage.js"),
-  stats:      path.join(__dirname, "lynkr-usage.js"),
-  trajectory: path.join(__dirname, "lynkr-trajectory.js"),
-  wrap:       path.join(__dirname, "wrap.js"),
-  init:       path.join(__dirname, "lynkr-init.js"),
-  reset:      path.join(__dirname, "lynkr-reset.js"),
+  usage:         path.join(__dirname, "lynkr-usage.js"),
+  stats:         path.join(__dirname, "lynkr-usage.js"),
+  trajectory:    path.join(__dirname, "lynkr-trajectory.js"),
+  wrap:          path.join(__dirname, "wrap.js"),
+  init:          path.join(__dirname, "lynkr-init.js"),
+  reset:         path.join(__dirname, "lynkr-reset.js"),
+  "desktop-token": path.join(__dirname, "lynkr-desktop-token.js"),
+  restart:       path.join(__dirname, "lynkr-restart.js"),
+  run:           path.join(__dirname, "run.js"),
 };
 
 const sub = process.argv[2];
@@ -51,6 +54,11 @@ Usage:
   lynkr start [options]            Alias for the above
   lynkr init [options]             Interactive setup wizard (writes .env, pulls classifier model)
   lynkr wrap <target> [options]    Wrap CLI tools through Lynkr proxy
+  lynkr desktop-token <token>      Apply a Claude Pro/Max OAuth token to Claude Desktop's
+                                    gateway profile (macOS only)
+  lynkr desktop-token --restore    Restore Claude Desktop to talking to Anthropic directly
+                                    (undoes the above; macOS only)
+  lynkr restart                    Restart the local Lynkr server (pick up code/config changes)
   lynkr usage [options]            Show AI spend report and tier-routing savings
   lynkr stats [options]            Shareable savings-receipt card (also: lynkr usage --card)
   lynkr trajectory [options]       Export agent trajectories as JSONL training data

package/bin/lynkr-desktop-token.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * `lynkr desktop-token <token>` / `lynkr desktop-token --restore`
+ *
+ * Apply a freshly-minted Claude Pro/Max OAuth token to Claude Desktop's
+ * Lynkr gateway profile — or restore Desktop back to talking to Anthropic
+ * directly.
+ *
+ * This does NOT mint or refresh the token — that stays a manual, one-time
+ * `claude setup-token` (interactive browser approval) every time it expires.
+ * It does NOT restart Lynkr, either: the token lives entirely in Desktop's
+ * own config file (read at Desktop's launch, not Lynkr's), and Lynkr just
+ * forwards whatever bearer shows up on each request — it has no token state
+ * of its own to refresh. Restarting only matters when Lynkr's own code
+ * changed; use `lynkr restart` for that, separately.
+ *
+ * `lynkr desktop-token <token>`:
+ *   1. Installs the token into the Desktop "3p" gateway profile
+ *      (delegates to scripts/claude-desktop.js --install)
+ *   2. Prints --status so you can see the profile actually took
+ *
+ * `lynkr desktop-token --restore`:
+ *   Delegates to scripts/claude-desktop.js --restore — puts Desktop's
+ *   deployment mode and applied-profile bookkeeping back to what they were
+ *   before Lynkr's gateway profile was installed, and removes the profile
+ *   + backup files. Safe to run even if nothing was ever installed (a
+ *   no-op restore, not an error).
+ *
+ * Neither variant touches .env TIER_* values, and neither quits or
+ * relaunches Claude Desktop itself (that would close your open chat
+ * windows) — both just print the command to do so when you're ready.
+ *
+ * Usage:
+ *   lynkr desktop-token sk-ant-oat01-...
+ *   lynkr desktop-token --restore
+ */
+
+const path = require("path");
+const fs = require("fs");
+const { execFileSync } = require("child_process");
+
+const ROOT = path.join(__dirname, "..");
+const ENV_PATH = path.join(ROOT, ".env");
+const CLAUDE_DESKTOP_JS = path.join(ROOT, "scripts", "claude-desktop.js");
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+function readPort() {
+  try {
+    const env = fs.readFileSync(ENV_PATH, "utf8");
+    const m = env.match(/^PORT=(\d+)/m);
+    if (m) return Number(m[1]);
+  } catch (err) {
+    console.error(`Couldn't read PORT from ${ENV_PATH} (${err.message}) — defaulting to 8081.`);
+  }
+  return 8081;
+}
+
+function main() {
+  const token = process.argv[2];
+  if (!token || token === "-h" || token === "--help") {
+    fail("Usage: lynkr desktop-token <sk-ant-oat-token> | --restore");
+  }
+  if (token === "--restore") {
+    if (process.platform !== "darwin") {
+      fail("Claude Desktop profile management is only supported on macOS.");
+    }
+    console.log("Restoring Claude Desktop to the usual Claude profile...");
+    execFileSync("node", [CLAUDE_DESKTOP_JS, "--restore"], { stdio: "inherit" });
+    console.log(
+      "\nWhen you're ready (this would close your open chats if done automatically):" +
+        "\n  killall Claude && open -a Claude"
+    );
+    return;
+  }
+  if (!token.startsWith("sk-ant-oat")) {
+    fail(
+      `That doesn't look like a Claude Code OAuth access token (expected it to start ` +
+        `with "sk-ant-oat"). Got: ${token.slice(0, 12)}...\n` +
+        `Mint one with: claude setup-token`
+    );
+  }
+  if (process.platform !== "darwin") {
+    fail("Claude Desktop profile management is only supported on macOS.");
+  }
+
+  const url = `http://127.0.0.1:${readPort()}`;
+
+  console.log("Step 1/2 — installing token into Claude Desktop's Lynkr gateway profile...");
+  execFileSync("node", [CLAUDE_DESKTOP_JS, "--install", "--url", url, "--key", token], {
+    stdio: "inherit",
+  });
+
+  console.log("\nStep 2/2 — status:");
+  execFileSync("node", [CLAUDE_DESKTOP_JS, "--status"], { stdio: "inherit" });
+
+  console.log(
+    "\nNext (manual, on purpose — this would close your open chats if done for you):" +
+      "\n  killall Claude && open -a Claude" +
+      "\n\nWhen Anthropic calls start 401ing: claude setup-token, then: lynkr desktop-token <token>" +
+      "\nIf you've also changed Lynkr's own code, that's a separate step: lynkr restart"
+  );
+}
+
+main();

package/bin/lynkr-init.js

@@ -179,12 +179,21 @@ const PROVIDERS = {
     extras: [],
     defaultModel: 'ernie-4.5-turbo-128k',
   },
+  fireworks: {
+    label: 'Fireworks AI (serverless open models)',
+    local: false,
+    creds: [
+      { key: 'FIREWORKS_API_KEY', label: 'Fireworks API key (fw-...)', secret: true },
+    ],
+    extras: [],
+    defaultModel: 'accounts/fireworks/models/kimi-k2-instruct-0905',
+  },
 };
 
 const PROVIDER_ORDER = [
   'ollama', 'llamacpp', 'lmstudio',
   'azure-anthropic', 'azure-openai', 'openai', 'atlas', 'openrouter', 'edenai',
-  'databricks', 'bedrock', 'vertex', 'zai', 'moonshot', 'baidu',
+  'databricks', 'bedrock', 'vertex', 'zai', 'moonshot', 'baidu', 'fireworks',
 ];
 const TIERS = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
 
@@ -342,6 +351,9 @@ const BASELINE_ENV = {
   BAIDU_API_KEY: '',
   BAIDU_ENDPOINT: 'https://qianfan.baidubce.com/v2/chat/completions',
   BAIDU_MODEL: 'ernie-4.5-turbo-128k',
+  FIREWORKS_API_KEY: '',
+  FIREWORKS_ENDPOINT: 'https://api.fireworks.ai/inference/v1/chat/completions',
+  FIREWORKS_MODEL: 'accounts/fireworks/models/kimi-k2-instruct-0905',
   LLAMACPP_ENDPOINT: 'http://localhost:8080',
   LLAMACPP_MODEL: 'default',
   LLAMACPP_TIMEOUT_MS: '120000',

package/bin/lynkr-restart.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/**
+ * `lynkr restart`
+ *
+ * Stop whatever's listening on Lynkr's configured port and start a fresh
+ * `npm start`, detached so it survives this command exiting. Use this after
+ * changing Lynkr's own code (routing, config, etc.) — it has nothing to do
+ * with Claude Desktop's token or profile, which Desktop reads from disk at
+ * its own launch time, independent of whether Lynkr's process restarts.
+ * See `lynkr desktop-token` for that.
+ *
+ * Usage:
+ *   lynkr restart
+ */
+
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+const { execFileSync, spawn } = require("child_process");
+
+const ROOT = path.join(__dirname, "..");
+const ENV_PATH = path.join(ROOT, ".env");
+const LOG_PATH = path.join(ROOT, "data", "logs", "lynkr-desktop.log");
+
+function fail(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+
+function readPort() {
+  try {
+    const env = fs.readFileSync(ENV_PATH, "utf8");
+    const m = env.match(/^PORT=(\d+)/m);
+    if (m) return Number(m[1]);
+  } catch (err) {
+    console.error(`Couldn't read PORT from ${ENV_PATH} (${err.message}) — defaulting to 8081.`);
+  }
+  return 8081;
+}
+
+function findListeningPid(port) {
+  try {
+    const out = execFileSync("lsof", ["-iTCP:" + port, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    return out ? out.split("\n").map((s) => s.trim()).filter(Boolean) : [];
+  } catch {
+    return []; // lsof exits non-zero when nothing matches
+  }
+}
+
+function healthCheck(port) {
+  return new Promise((resolve) => {
+    const req = http.get({ host: "127.0.0.1", port, path: "/health", timeout: 1500 }, (res) => {
+      let body = "";
+      res.on("data", (d) => (body += d));
+      res.on("end", () => {
+        try {
+          resolve(res.statusCode === 200 && JSON.parse(body).status === "ok");
+        } catch {
+          resolve(false);
+        }
+      });
+    });
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+async function waitForHealth(port, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await healthCheck(port)) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+
+async function main() {
+  if (process.argv[2] === "-h" || process.argv[2] === "--help") {
+    console.log("Usage: lynkr restart");
+    process.exit(0);
+  }
+
+  const port = readPort();
+  const pids = findListeningPid(port);
+  if (pids.length) {
+    console.log(`Stopping existing Lynkr process (pid ${pids.join(", ")}) on port ${port}...`);
+    for (const pid of pids) {
+      try {
+        process.kill(Number(pid), "SIGTERM");
+      } catch (err) {
+        console.warn(`  couldn't signal pid ${pid}: ${err.message}`);
+      }
+    }
+    const freedByDeadline = Date.now() + 5000;
+    while (Date.now() < freedByDeadline && findListeningPid(port).length) {
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  } else {
+    console.log(`Nothing currently listening on port ${port}.`);
+  }
+
+  fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+  const logFd = fs.openSync(LOG_PATH, "a");
+  console.log(`Starting Lynkr (npm start), logging to ${LOG_PATH}...`);
+  const child = spawn("npm", ["start"], {
+    cwd: ROOT,
+    stdio: ["ignore", logFd, logFd],
+    detached: true,
+  });
+  child.unref();
+
+  const up = await waitForHealth(port, 15000);
+  if (!up) {
+    fail(`Lynkr didn't answer /health on port ${port} within 15s.\nCheck ${LOG_PATH} for errors.`);
+  }
+  console.log(`Lynkr is up on http://127.0.0.1:${port}.`);
+}
+
+main().catch((err) => fail(err.stack || String(err)));

package/bin/opencode-setup.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * lynkr opencode — write the Lynkr provider into opencode's config with
+ * HONEST per-tier context windows.
+ *
+ * The problem this solves: opencode's compaction triggers off ONE static
+ * `limit.context` per model entry, but Lynkr's tier routing serves models
+ * with different real windows (e.g. 128k / 200k / 1M). One blended number is
+ * wrong for most requests: too big and opencode never compacts in time (the
+ * conversation outgrows the served model and Lynkr's server-side compressor
+ * has to amputate it mechanically); too small and big-window models are
+ * wasted.
+ *
+ * The fix: one opencode model entry per tier, each carrying its tier's REAL
+ * configured-model window (read live from this Lynkr install's TIER_* config
+ * and model registry), plus a "lynkr-auto" entry floored at the MINIMUM
+ * across tiers (safe for whatever routing picks). The per-tier ids
+ * (lynkr-simple/medium/complex/reasoning) pin their tier server-side — see
+ * src/routing/model-slots.js VIRTUAL_TIER_IDS — so the window each entry
+ * advertises is the window that actually serves it. Picking a tier in
+ * opencode's model picker doubles as tier pinning (documentation/
+ * tier-pinning.md), and compaction budgets stay correct per model.
+ *
+ * Usage:
+ *   lynkr opencode                       # merge into ~/.config/opencode/opencode.json
+ *   lynkr opencode --path ./opencode.json  # project-scoped config instead
+ *   lynkr opencode --base-url http://host:8081
+ *   lynkr opencode --dry-run             # print the block, write nothing
+ *
+ * Merging is non-destructive: only the `provider.lynkr` block is replaced;
+ * every other key in an existing opencode.json is preserved verbatim.
+ *
+ * @module bin/opencode-setup
+ */
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const TIERS = ["SIMPLE", "MEDIUM", "COMPLEX", "REASONING"];
+
+/**
+ * Read each configured tier's model and its real context window.
+ * @returns {{ tiers: Object<string, {provider: string, model: string, contextWindow: number|null}>, minWindow: number|null }}
+ */
+function readTierWindows() {
+  const config = require("../src/config");
+  const { contextWindowFor } = require("../src/routing/model-registry");
+  const tiers = {};
+  let minWindow = null;
+  for (const tier of TIERS) {
+    const raw = config.modelTiers?.[tier];
+    if (!raw) continue;
+    const [provider, ...rest] = raw.split(":");
+    const model = rest.join(":") || null;
+    const contextWindow = model ? contextWindowFor(model) : null;
+    tiers[tier] = { provider, model, contextWindow };
+    if (contextWindow && (!minWindow || contextWindow < minWindow)) {
+      minWindow = contextWindow;
+    }
+  }
+  return { tiers, minWindow };
+}
+
+// Conservative floor when no tier window is resolvable (fresh install,
+// unpriced local models): matches the orchestrator's TOKEN_BUDGET_FALLBACK
+// rationale — never advertise bigger than what's known safe.
+const FALLBACK_WINDOW = 128000;
+
+/**
+ * Build the `provider.lynkr` block for opencode.json. Pure — exported for
+ * tests.
+ *
+ * @param {{ tiers: Object, minWindow: number|null }} tierWindows
+ * @param {{ baseURL: string, apiKey: string }} options
+ * @returns {object} provider block
+ */
+function buildLynkrProvider(tierWindows, { baseURL, apiKey }) {
+  const models = {
+    "lynkr-auto": {
+      name: "Lynkr Auto (tier routing)",
+      limit: { context: tierWindows.minWindow || FALLBACK_WINDOW },
+    },
+  };
+  for (const tier of TIERS) {
+    const entry = tierWindows.tiers[tier];
+    if (!entry?.model) continue;
+    models[`lynkr-${tier.toLowerCase()}`] = {
+      name: `Lynkr ${tier} (${entry.model})`,
+      limit: { context: entry.contextWindow || tierWindows.minWindow || FALLBACK_WINDOW },
+    };
+  }
+  return {
+    npm: "@ai-sdk/anthropic",
+    name: "Lynkr",
+    options: {
+      baseURL: `${baseURL.replace(/\/+$/, "")}/v1`,
+      apiKey,
+    },
+    models,
+  };
+}
+
+/**
+ * Merge the Lynkr provider into an existing opencode config object without
+ * touching anything else. Pure — exported for tests.
+ */
+function mergeOpencodeConfig(existing, lynkrProvider) {
+  const merged = { ...(existing || {}) };
+  merged.provider = { ...(merged.provider || {}), lynkr: lynkrProvider };
+  return merged;
+}
+
+function defaultConfigPath() {
+  return path.join(os.homedir(), ".config", "opencode", "opencode.json");
+}
+
+/**
+ * Perform the setup. Exported so `lynkr run opencode` (bin/run.js) can
+ * configure-then-launch. Returns { dryRun } so the caller knows whether to
+ * proceed to launching.
+ * @param {string[]} args - CLI-style flag list
+ */
+function runSetup(args) {
+  const argValue = (flag) => {
+    const i = args.indexOf(flag);
+    return i !== -1 && i + 1 < args.length ? args[i + 1] : null;
+  };
+  const configPath = argValue("--path") || defaultConfigPath();
+  const baseURL = argValue("--base-url")
+    || `http://localhost:${process.env.PORT || 8081}`;
+  const apiKey = process.env.LYNKR_API_KEY || "lynkr-local";
+  const dryRun = args.includes("--dry-run");
+
+  const tierWindows = readTierWindows();
+  const provider = buildLynkrProvider(tierWindows, { baseURL, apiKey });
+
+  console.log("Lynkr → opencode provider block (per-tier context windows):\n");
+  for (const [id, m] of Object.entries(provider.models)) {
+    console.log(`  ${id.padEnd(16)} limit.context=${String(m.limit.context).padStart(8)}  ${m.name}`);
+  }
+  const unresolved = TIERS.filter(
+    (t) => tierWindows.tiers[t]?.model && !tierWindows.tiers[t]?.contextWindow
+  );
+  if (unresolved.length > 0) {
+    console.warn(`\n⚠ No registry context window for tier model(s): ${unresolved
+      .map((t) => `${t}=${tierWindows.tiers[t].model}`)
+      .join(", ")} — floored conservatively. Add MODEL_PRICE_OVERRIDES entries (with a context field) to fix.`);
+  }
+
+  if (dryRun) {
+    console.log(`\n--dry-run: would merge into ${configPath}`);
+    console.log(JSON.stringify({ provider: { lynkr: provider } }, null, 2));
+    return { dryRun: true };
+  }
+
+  let existing = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    } catch (err) {
+      console.error(`\nRefusing to overwrite ${configPath}: it exists but isn't valid JSON (${err.message}).`);
+      console.error("Fix or move it, then re-run.");
+      process.exit(1);
+    }
+  }
+
+  const merged = mergeOpencodeConfig(existing, provider);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n");
+  console.log(`\n✓ Merged provider.lynkr into ${configPath} (other keys preserved).`);
+  return { dryRun: false };
+}
+
+module.exports = { buildLynkrProvider, mergeOpencodeConfig, readTierWindows, runSetup, FALLBACK_WINDOW };

package/bin/run.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * lynkr run <tool> — ensure the tool's Lynkr provider config is current,
+ * then launch the tool.
+ *
+ * Differs from `lynkr wrap` on purpose: wrap intercepts a tool's traffic via
+ * environment overrides at launch; `run` writes the tool's own native
+ * provider config (so the tool works with Lynkr even when started normally
+ * later) and then execs it. Config refresh on every run keeps the per-tier
+ * context windows in sync with TIER_* changes.
+ *
+ * Usage:
+ *   lynkr run opencode                    # refresh config, launch opencode
+ *   lynkr run opencode --dry-run          # preview config, don't write or launch
+ *   lynkr run opencode --path ./opencode.json --base-url http://host:8081
+ *   lynkr run opencode -- --help          # everything after -- goes to opencode
+ *
+ * @module bin/run
+ */
+
+const { spawn } = require("child_process");
+
+// Flags consumed by the setup step (with whether they take a value).
+const SETUP_FLAGS = new Map([
+  ["--dry-run", false],
+  ["--path", true],
+  ["--base-url", true],
+]);
+
+function splitArgs(args) {
+  const setupArgs = [];
+  const toolArgs = [];
+  let passthrough = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (passthrough) {
+      toolArgs.push(arg);
+      continue;
+    }
+    if (arg === "--") {
+      passthrough = true;
+      continue;
+    }
+    if (SETUP_FLAGS.has(arg)) {
+      setupArgs.push(arg);
+      if (SETUP_FLAGS.get(arg) && i + 1 < args.length) setupArgs.push(args[++i]);
+      continue;
+    }
+    toolArgs.push(arg);
+  }
+  return { setupArgs, toolArgs };
+}
+
+function runOpencode(args) {
+  const { runSetup } = require("./opencode-setup");
+  const { setupArgs, toolArgs } = splitArgs(args);
+  const { dryRun } = runSetup(setupArgs) || {};
+  if (dryRun) return;
+
+  const child = spawn("opencode", toolArgs, { stdio: "inherit" });
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error("\nConfig written, but the `opencode` binary was not found on PATH.");
+      console.error("Install it (https://opencode.ai), then run `opencode` — the Lynkr provider is already configured.");
+      process.exit(127);
+    }
+    console.error(`Failed to launch opencode: ${err.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code, signal) => {
+    process.exit(signal ? 1 : (code ?? 0));
+  });
+}
+
+const TOOLS = { opencode: runOpencode };
+
+function main() {
+  const [tool, ...rest] = process.argv.slice(2);
+  if (!tool || !Object.prototype.hasOwnProperty.call(TOOLS, tool)) {
+    console.error(`Usage: lynkr run <tool> [options] [-- tool-args]`);
+    console.error(`Supported tools: ${Object.keys(TOOLS).join(", ")}`);
+    console.error(tool ? `Unknown tool '${tool}'.` : "");
+    process.exit(tool ? 1 : 0);
+  }
+  TOOLS[tool](rest);
+}
+
+module.exports = { splitArgs, TOOLS };
+
+if (require.main === module || process.env._LYNKR_SUBCMD === "run") {
+  main();
+}

package/config/model-capabilities.json

@@ -0,0 +1,20 @@
+{
+  "version": 1,
+  "heads": ["reasoning", "codegen", "debugging", "tool_use"],
+  "notes": "Capability profiles are decoupled from the predictor (see src/routing/capabilities.js). Editing this file re-routes traffic with zero retraining — the HyDRA shortfall-matching port. Tier profiles are seeded to mirror the legacy scalar bands (SIMPLE 0-19, MEDIUM 20-50, COMPLEX 51-75, REASONING 76-100). This file is read once at boot (same as config/model-tiers.json) — restart to pick up edits. No env vars: everything shortfall needs lives here.",
+  "enabled": true,
+  "tau": 0.24,
+  "weights": {
+    "reasoning": 0.25,
+    "codegen": 0.25,
+    "debugging": 0.25,
+    "tool_use": 0.25
+  },
+  "tierProfiles": {
+    "SIMPLE": { "reasoning": 0.2, "codegen": 0.3, "debugging": 0.2, "tool_use": 0.3 },
+    "MEDIUM": { "reasoning": 0.45, "codegen": 0.55, "debugging": 0.45, "tool_use": 0.55 },
+    "COMPLEX": { "reasoning": 0.7, "codegen": 0.75, "debugging": 0.7, "tool_use": 0.7 },
+    "REASONING": { "reasoning": 0.9, "codegen": 0.9, "debugging": 0.9, "tool_use": 0.9 }
+  },
+  "modelOverrides": {}
+}