@newtype-ai/nit 0.4.8 → 0.4.10

package/dist/chunk-7LNGTHKO.js

@@ -1,1601 +0,0 @@
-// nit — version control for agent cards
-
-// src/index.ts
-import { promises as fs7, statSync } from "fs";
-import { join as join7, basename as basename2, dirname as dirname2, resolve as resolve2 } from "path";
-
-// src/objects.ts
-import { createHash } from "crypto";
-import { promises as fs } from "fs";
-import { join } from "path";
-function hashObject(type, content) {
-  const buf = Buffer.from(content, "utf-8");
-  const header = `${type} ${buf.byteLength}\0`;
-  const hash = createHash("sha256");
-  hash.update(header);
-  hash.update(buf);
-  return hash.digest("hex");
-}
-async function writeObject(nitDir, type, content) {
-  const hex = hashObject(type, content);
-  const dir = join(nitDir, "objects", hex.slice(0, 2));
-  const file = join(dir, hex.slice(2));
-  try {
-    await fs.access(file);
-    return hex;
-  } catch {
-  }
-  await fs.mkdir(dir, { recursive: true });
-  await fs.writeFile(file, content, "utf-8");
-  return hex;
-}
-async function readObject(nitDir, hash) {
-  const file = join(nitDir, "objects", hash.slice(0, 2), hash.slice(2));
-  try {
-    return await fs.readFile(file, "utf-8");
-  } catch {
-    throw new Error(`Object not found: ${hash}`);
-  }
-}
-function serializeCommit(commit2) {
-  const lines = [];
-  lines.push(`card ${commit2.card}`);
-  if (commit2.parent !== null) {
-    lines.push(`parent ${commit2.parent}`);
-  }
-  lines.push(`author ${commit2.author} ${commit2.timestamp}`);
-  lines.push("");
-  lines.push(commit2.message);
-  return lines.join("\n");
-}
-function parseCommit(hash, raw) {
-  const lines = raw.split("\n");
-  let card = "";
-  let parent = null;
-  let author = "";
-  let timestamp = 0;
-  let messageStart = -1;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line === "") {
-      messageStart = i + 1;
-      break;
-    }
-    if (line.startsWith("card ")) {
-      card = line.slice(5);
-    } else if (line.startsWith("parent ")) {
-      parent = line.slice(7);
-    } else if (line.startsWith("author ")) {
-      const authorPart = line.slice(7);
-      const lastSpace = authorPart.lastIndexOf(" ");
-      author = authorPart.slice(0, lastSpace);
-      timestamp = parseInt(authorPart.slice(lastSpace + 1), 10);
-    }
-  }
-  if (!card) {
-    throw new Error(`Malformed commit object ${hash}: missing card hash`);
-  }
-  const message = messageStart >= 0 ? lines.slice(messageStart).join("\n") : "";
-  return {
-    type: "commit",
-    hash,
-    card,
-    parent,
-    author,
-    timestamp,
-    message
-  };
-}
-
-// src/refs.ts
-import { promises as fs2 } from "fs";
-import { join as join2 } from "path";
-async function getHead(nitDir) {
-  const headPath = join2(nitDir, "HEAD");
-  const content = (await fs2.readFile(headPath, "utf-8")).trim();
-  if (!content.startsWith("ref: ")) {
-    throw new Error(
-      `HEAD is in an unexpected state: "${content}". Only symbolic refs are supported.`
-    );
-  }
-  return { type: "ref", ref: content.slice(5) };
-}
-async function resolveHead(nitDir) {
-  const head = await getHead(nitDir);
-  const refPath = join2(nitDir, head.ref);
-  try {
-    return (await fs2.readFile(refPath, "utf-8")).trim();
-  } catch {
-    throw new Error(
-      `Branch ref ${head.ref} does not exist. Repository may be empty.`
-    );
-  }
-}
-async function getCurrentBranch(nitDir) {
-  const head = await getHead(nitDir);
-  const prefix = "refs/heads/";
-  if (!head.ref.startsWith(prefix)) {
-    throw new Error(`HEAD ref has unexpected format: ${head.ref}`);
-  }
-  return head.ref.slice(prefix.length);
-}
-async function setBranch(nitDir, branch2, commitHash) {
-  const refPath = join2(nitDir, "refs", "heads", branch2);
-  await fs2.mkdir(join2(nitDir, "refs", "heads"), { recursive: true });
-  await fs2.writeFile(refPath, commitHash + "\n", "utf-8");
-}
-async function getBranch(nitDir, branch2) {
-  const refPath = join2(nitDir, "refs", "heads", branch2);
-  try {
-    return (await fs2.readFile(refPath, "utf-8")).trim();
-  } catch {
-    return null;
-  }
-}
-async function listBranches(nitDir) {
-  const headsDir = join2(nitDir, "refs", "heads");
-  const branches = [];
-  try {
-    const entries = await fs2.readdir(headsDir);
-    for (const name of entries) {
-      const refPath = join2(headsDir, name);
-      const stat = await fs2.stat(refPath);
-      if (stat.isFile()) {
-        const commitHash = (await fs2.readFile(refPath, "utf-8")).trim();
-        branches.push({ name, commitHash });
-      }
-    }
-  } catch {
-  }
-  return branches.sort((a, b) => a.name.localeCompare(b.name));
-}
-async function setHead(nitDir, branch2) {
-  const headPath = join2(nitDir, "HEAD");
-  await fs2.writeFile(headPath, `ref: refs/heads/${branch2}
-`, "utf-8");
-}
-async function setRemoteRef(nitDir, remote2, branch2, commitHash) {
-  const dir = join2(nitDir, "refs", "remote", remote2);
-  await fs2.mkdir(dir, { recursive: true });
-  await fs2.writeFile(join2(dir, branch2), commitHash + "\n", "utf-8");
-}
-async function getRemoteRef(nitDir, remote2, branch2) {
-  const refPath = join2(nitDir, "refs", "remote", remote2, branch2);
-  try {
-    return (await fs2.readFile(refPath, "utf-8")).trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/identity.ts
-import {
-  createHash as createHash2,
-  generateKeyPairSync,
-  createPrivateKey,
-  createPublicKey,
-  sign,
-  verify
-} from "crypto";
-import { promises as fs3 } from "fs";
-import { join as join3 } from "path";
-function base64urlToBase64(b64url) {
-  let s = b64url.replace(/-/g, "+").replace(/_/g, "/");
-  while (s.length % 4 !== 0) s += "=";
-  return s;
-}
-function base64ToBase64url(b64) {
-  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-async function generateKeypair(nitDir) {
-  const identityDir = join3(nitDir, "identity");
-  await fs3.mkdir(identityDir, { recursive: true });
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  const pubJwk = publicKey.export({ format: "jwk" });
-  const privJwk = privateKey.export({ format: "jwk" });
-  const pubBase64 = base64urlToBase64(pubJwk.x);
-  const privBase64 = base64urlToBase64(privJwk.d);
-  const pubPath = join3(identityDir, "agent.pub");
-  const keyPath = join3(identityDir, "agent.key");
-  await fs3.writeFile(pubPath, pubBase64 + "\n", "utf-8");
-  await fs3.writeFile(keyPath, privBase64 + "\n", {
-    mode: 384,
-    encoding: "utf-8"
-  });
-  return { publicKey: pubBase64, privateKey: privBase64 };
-}
-async function loadPublicKey(nitDir) {
-  const pubPath = join3(nitDir, "identity", "agent.pub");
-  try {
-    return (await fs3.readFile(pubPath, "utf-8")).trim();
-  } catch {
-    throw new Error(
-      "No identity found. Run `nit init` to generate a keypair."
-    );
-  }
-}
-async function loadPrivateKey(nitDir) {
-  const pubBase64 = await loadPublicKey(nitDir);
-  const keyPath = join3(nitDir, "identity", "agent.key");
-  let privBase64;
-  try {
-    privBase64 = (await fs3.readFile(keyPath, "utf-8")).trim();
-  } catch {
-    throw new Error(
-      "Private key not found at .nit/identity/agent.key. Regenerate with `nit init`."
-    );
-  }
-  const xB64url = base64ToBase64url(pubBase64);
-  const dB64url = base64ToBase64url(privBase64);
-  return createPrivateKey({
-    key: { kty: "OKP", crv: "Ed25519", x: xB64url, d: dB64url },
-    format: "jwk"
-  });
-}
-async function loadRawKeyPair(nitDir) {
-  const pubBase64 = await loadPublicKey(nitDir);
-  const keyPath = join3(nitDir, "identity", "agent.key");
-  let privBase64;
-  try {
-    privBase64 = (await fs3.readFile(keyPath, "utf-8")).trim();
-  } catch {
-    throw new Error(
-      "Private key not found at .nit/identity/agent.key. Regenerate with `nit init`."
-    );
-  }
-  const seed = Buffer.from(privBase64, "base64");
-  const pubkey = Buffer.from(pubBase64, "base64");
-  const keypair = new Uint8Array(64);
-  keypair.set(seed, 0);
-  keypair.set(pubkey, 32);
-  return keypair;
-}
-function formatPublicKeyField(pubBase64) {
-  return `ed25519:${pubBase64}`;
-}
-function parsePublicKeyField(field) {
-  const prefix = "ed25519:";
-  if (!field.startsWith(prefix)) {
-    throw new Error(
-      `Invalid publicKey format: expected "ed25519:<base64>", got "${field}"`
-    );
-  }
-  return field.slice(prefix.length);
-}
-async function signChallenge(nitDir, challenge) {
-  const privateKey = await loadPrivateKey(nitDir);
-  const sig = sign(null, Buffer.from(challenge, "utf-8"), privateKey);
-  return sig.toString("base64");
-}
-async function signMessage(nitDir, message) {
-  const privateKey = await loadPrivateKey(nitDir);
-  const sig = sign(null, Buffer.from(message, "utf-8"), privateKey);
-  return sig.toString("base64");
-}
-var NIT_NAMESPACE = "801ba518-f326-47e5-97c9-d1efd1865a19";
-function deriveAgentId(publicKeyField) {
-  return uuidv5(publicKeyField, NIT_NAMESPACE);
-}
-async function loadAgentId(nitDir) {
-  const idPath = join3(nitDir, "identity", "agent-id");
-  try {
-    return (await fs3.readFile(idPath, "utf-8")).trim();
-  } catch {
-    throw new Error(
-      "No agent ID found. Run `nit init` to generate identity."
-    );
-  }
-}
-async function saveAgentId(nitDir, agentId) {
-  const idPath = join3(nitDir, "identity", "agent-id");
-  await fs3.writeFile(idPath, agentId + "\n", "utf-8");
-}
-function parseUuid(uuid) {
-  const hex = uuid.replace(/-/g, "");
-  return Buffer.from(hex, "hex");
-}
-function formatUuid(bytes) {
-  const hex = bytes.toString("hex");
-  return [
-    hex.slice(0, 8),
-    hex.slice(8, 12),
-    hex.slice(12, 16),
-    hex.slice(16, 20),
-    hex.slice(20, 32)
-  ].join("-");
-}
-function uuidv5(name, namespace) {
-  const namespaceBytes = parseUuid(namespace);
-  const nameBytes = Buffer.from(name, "utf-8");
-  const data = Buffer.concat([namespaceBytes, nameBytes]);
-  const hash = createHash2("sha1").update(data).digest();
-  const uuid = Buffer.from(hash.subarray(0, 16));
-  uuid[6] = uuid[6] & 15 | 80;
-  uuid[8] = uuid[8] & 63 | 128;
-  return formatUuid(uuid);
-}
-
-// src/skills.ts
-import { promises as fs4 } from "fs";
-import { join as join4, resolve } from "path";
-import { homedir } from "os";
-var FRAMEWORK_MARKERS = [
-  { marker: ".claude", skillsPath: ".claude/skills", innerSkillsPath: "skills" },
-  { marker: ".cursor", skillsPath: ".cursor/skills", innerSkillsPath: "skills" },
-  { marker: ".codex", skillsPath: ".codex/skills", innerSkillsPath: "skills" },
-  { marker: ".windsurf", skillsPath: ".windsurf/skills", innerSkillsPath: "skills" },
-  { marker: ".openclaw", skillsPath: ".openclaw/workspace/skills", innerSkillsPath: ".agent/skills" }
-];
-var GLOBAL_SKILLS_DIRS = [
-  { marker: ".claude", skillsPath: ".claude/skills" },
-  { marker: ".codex", skillsPath: ".codex/skills" },
-  { marker: ".codeium", skillsPath: ".codeium/windsurf/skills" }
-];
-async function discoverSkillsDir(projectDir2) {
-  const absProject = resolve(projectDir2);
-  const home = homedir();
-  for (const { marker, innerSkillsPath } of FRAMEWORK_MARKERS) {
-    if (absProject.includes(`/${marker}/`) || absProject.includes(`/${marker}`)) {
-      return join4(absProject, innerSkillsPath);
-    }
-  }
-  for (const { marker, skillsPath } of FRAMEWORK_MARKERS) {
-    try {
-      const stat = await fs4.stat(join4(absProject, marker));
-      if (stat.isDirectory()) {
-        return join4(absProject, skillsPath);
-      }
-    } catch {
-    }
-  }
-  for (const { marker, skillsPath } of GLOBAL_SKILLS_DIRS) {
-    try {
-      const stat = await fs4.stat(join4(home, marker));
-      if (stat.isDirectory()) {
-        return join4(home, skillsPath);
-      }
-    } catch {
-    }
-  }
-  return join4(absProject, ".agents", "skills");
-}
-async function createSkillTemplate(skillsDir, domain) {
-  const skillId = domain.replace(/\./g, "-");
-  const skillDir = join4(skillsDir, skillId);
-  const skillPath = join4(skillDir, "SKILL.md");
-  let localVersion;
-  try {
-    const existing = await fs4.readFile(skillPath, "utf-8");
-    localVersion = parseVersion(existing);
-  } catch {
-  }
-  let remoteContent = null;
-  let remoteVersion;
-  try {
-    const res = await fetch(`https://${domain}/skill.md`, {
-      headers: { "Accept": "text/markdown, text/plain" },
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (res.ok) {
-      const text = await res.text();
-      if (text.startsWith("---")) {
-        remoteContent = text;
-        remoteVersion = parseVersion(text);
-      }
-    }
-  } catch {
-  }
-  if (localVersion !== void 0) {
-    if (!remoteVersion || !isNewerVersion(remoteVersion, localVersion)) {
-      return skillId;
-    }
-  }
-  await fs4.mkdir(skillDir, { recursive: true });
-  await fs4.writeFile(
-    skillPath,
-    remoteContent ?? fallbackTemplate(skillId, domain),
-    "utf-8"
-  );
-  return skillId;
-}
-function parseVersion(content) {
-  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch) return void 0;
-  const versionMatch = fmMatch[1].match(/^version:\s*(.+)$/m);
-  return versionMatch ? versionMatch[1].trim() : void 0;
-}
-function isNewerVersion(remote2, local) {
-  const r = remote2.split(".").map(Number);
-  const l = local.split(".").map(Number);
-  const len = Math.max(r.length, l.length);
-  for (let i = 0; i < len; i++) {
-    const rv = r[i] ?? 0;
-    const lv = l[i] ?? 0;
-    if (rv > lv) return true;
-    if (rv < lv) return false;
-  }
-  return false;
-}
-function fallbackTemplate(skillId, domain) {
-  return `---
-name: ${skillId}
-description: Skills and context for ${domain}
----
-
-# ${skillId}
-
-Configure your skills and context for ${domain} here.
-`;
-}
-async function discoverSkills(projectDir2) {
-  const home = homedir();
-  const searchDirs = [
-    // Project-local (all known agent frameworks)
-    join4(projectDir2, ".claude", "skills"),
-    join4(projectDir2, ".cursor", "skills"),
-    join4(projectDir2, ".windsurf", "skills"),
-    join4(projectDir2, ".codex", "skills"),
-    join4(projectDir2, ".agent", "skills"),
-    // OpenClaw
-    join4(projectDir2, ".agents", "skills"),
-    // User-global
-    join4(home, ".claude", "skills"),
-    // Claude Code + Cursor (shared)
-    join4(home, ".codex", "skills"),
-    // Codex CLI
-    join4(home, ".codeium", "windsurf", "skills")
-    // Windsurf
-  ];
-  const seen = /* @__PURE__ */ new Set();
-  const skills = [];
-  for (const searchDir of searchDirs) {
-    const found = await scanSkillDir(searchDir);
-    for (const skill of found) {
-      if (!seen.has(skill.id)) {
-        seen.add(skill.id);
-        skills.push(skill);
-      }
-    }
-  }
-  return skills;
-}
-async function resolveSkillPointers(card, projectDir2) {
-  const discovered = await discoverSkills(projectDir2);
-  const skillMap = new Map(discovered.map((s) => [s.id, s]));
-  const resolvedSkills = card.skills.map((skill) => {
-    const meta = skillMap.get(skill.id);
-    if (!meta) return skill;
-    return {
-      ...skill,
-      name: meta.name,
-      description: meta.description
-    };
-  });
-  return { ...card, skills: resolvedSkills };
-}
-async function scanSkillDir(dir) {
-  let entries;
-  try {
-    entries = await fs4.readdir(dir);
-  } catch {
-    return [];
-  }
-  const skills = [];
-  for (const entry of entries) {
-    const skillMdPath = join4(dir, entry, "SKILL.md");
-    try {
-      const content = await fs4.readFile(skillMdPath, "utf-8");
-      const meta = parseFrontmatter(content, entry, skillMdPath);
-      if (meta) skills.push(meta);
-    } catch {
-    }
-  }
-  return skills;
-}
-function parseFrontmatter(content, dirName, filePath) {
-  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch) return null;
-  const fmBlock = fmMatch[1];
-  const fields = {};
-  let inMetadata = false;
-  let metadataVersion;
-  for (const line of fmBlock.split("\n")) {
-    const trimmed = line.trimEnd();
-    if (trimmed === "metadata:") {
-      inMetadata = true;
-      continue;
-    }
-    if (inMetadata) {
-      const nestedMatch = trimmed.match(/^\s+(\w+):\s*(.+)$/);
-      if (nestedMatch) {
-        if (nestedMatch[1] === "version") {
-          metadataVersion = nestedMatch[2].trim();
-        }
-        continue;
-      }
-      inMetadata = false;
-    }
-    const kvMatch = trimmed.match(/^(\w+):\s*(.+)$/);
-    if (kvMatch) {
-      fields[kvMatch[1]] = kvMatch[2].trim();
-    }
-  }
-  const name = fields["name"];
-  const description = fields["description"];
-  if (!name || !description) return null;
-  return {
-    id: dirName,
-    name,
-    description,
-    version: metadataVersion,
-    path: filePath
-  };
-}
-
-// src/wallet.ts
-import { createHmac, createECDH } from "crypto";
-import { promises as fs5 } from "fs";
-import { join as join5 } from "path";
-
-// node_modules/@noble/hashes/_u64.js
-var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-var _32n = /* @__PURE__ */ BigInt(32);
-function fromBig(n, le = false) {
-  if (le)
-    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
-  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-}
-function split(lst, le = false) {
-  const len = lst.length;
-  let Ah = new Uint32Array(len);
-  let Al = new Uint32Array(len);
-  for (let i = 0; i < len; i++) {
-    const { h, l } = fromBig(lst[i], le);
-    [Ah[i], Al[i]] = [h, l];
-  }
-  return [Ah, Al];
-}
-var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
-var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
-var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
-var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
-
-// node_modules/@noble/hashes/utils.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function anumber(n, title = "") {
-  if (!Number.isSafeInteger(n) || n < 0) {
-    const prefix = title && `"${title}" `;
-    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
-  }
-}
-function abytes(value, length, title = "") {
-  const bytes = isBytes(value);
-  const len = value?.length;
-  const needsLen = length !== void 0;
-  if (!bytes || needsLen && len !== length) {
-    const prefix = title && `"${title}" `;
-    const ofLen = needsLen ? ` of length ${length}` : "";
-    const got = bytes ? `length=${len}` : `type=${typeof value}`;
-    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-  }
-  return value;
-}
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function aoutput(out, instance) {
-  abytes(out, void 0, "digestInto() output");
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error('"digestInto() output" expected to be of length >=' + min);
-  }
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean(...arrays) {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-function byteSwap32(arr) {
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-var swap32IfBE = isLE ? (u) => u : byteSwap32;
-function createHasher(hashCons, info = {}) {
-  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-  const tmp = hashCons(void 0);
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = (opts) => hashCons(opts);
-  Object.assign(hashC, info);
-  return Object.freeze(hashC);
-}
-
-// node_modules/@noble/hashes/sha3.js
-var _0n = BigInt(0);
-var _1n = BigInt(1);
-var _2n = BigInt(2);
-var _7n = BigInt(7);
-var _256n = BigInt(256);
-var _0x71n = BigInt(113);
-var SHA3_PI = [];
-var SHA3_ROTL = [];
-var _SHA3_IOTA = [];
-for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-  [x, y] = [y, (2 * x + 3 * y) % 5];
-  SHA3_PI.push(2 * (5 * y + x));
-  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-  let t = _0n;
-  for (let j = 0; j < 7; j++) {
-    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
-    if (R & _2n)
-      t ^= _1n << (_1n << BigInt(j)) - _1n;
-  }
-  _SHA3_IOTA.push(t);
-}
-var IOTAS = split(_SHA3_IOTA, true);
-var SHA3_IOTA_H = IOTAS[0];
-var SHA3_IOTA_L = IOTAS[1];
-var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
-var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
-function keccakP(s, rounds = 24) {
-  const B = new Uint32Array(5 * 2);
-  for (let round = 24 - rounds; round < 24; round++) {
-    for (let x = 0; x < 10; x++)
-      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-    for (let x = 0; x < 10; x += 2) {
-      const idx1 = (x + 8) % 10;
-      const idx0 = (x + 2) % 10;
-      const B0 = B[idx0];
-      const B1 = B[idx0 + 1];
-      const Th = rotlH(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-      for (let y = 0; y < 50; y += 10) {
-        s[x + y] ^= Th;
-        s[x + y + 1] ^= Tl;
-      }
-    }
-    let curH = s[2];
-    let curL = s[3];
-    for (let t = 0; t < 24; t++) {
-      const shift = SHA3_ROTL[t];
-      const Th = rotlH(curH, curL, shift);
-      const Tl = rotlL(curH, curL, shift);
-      const PI = SHA3_PI[t];
-      curH = s[PI];
-      curL = s[PI + 1];
-      s[PI] = Th;
-      s[PI + 1] = Tl;
-    }
-    for (let y = 0; y < 50; y += 10) {
-      for (let x = 0; x < 10; x++)
-        B[x] = s[y + x];
-      for (let x = 0; x < 10; x++)
-        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-    }
-    s[0] ^= SHA3_IOTA_H[round];
-    s[1] ^= SHA3_IOTA_L[round];
-  }
-  clean(B);
-}
-var Keccak = class _Keccak {
-  state;
-  pos = 0;
-  posOut = 0;
-  finished = false;
-  state32;
-  destroyed = false;
-  blockLen;
-  suffix;
-  outputLen;
-  enableXOF = false;
-  rounds;
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-    this.blockLen = blockLen;
-    this.suffix = suffix;
-    this.outputLen = outputLen;
-    this.enableXOF = enableXOF;
-    this.rounds = rounds;
-    anumber(outputLen, "outputLen");
-    if (!(0 < blockLen && blockLen < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200);
-    this.state32 = u32(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    swap32IfBE(this.state32);
-    keccakP(this.state32, this.rounds);
-    swap32IfBE(this.state32);
-    this.posOut = 0;
-    this.pos = 0;
-  }
-  update(data) {
-    aexists(this);
-    abytes(data);
-    const { blockLen, state } = this;
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      for (let i = 0; i < take; i++)
-        state[this.pos++] ^= data[pos++];
-      if (this.pos === blockLen)
-        this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = true;
-    const { state, suffix, pos, blockLen } = this;
-    state[pos] ^= suffix;
-    if ((suffix & 128) !== 0 && pos === blockLen - 1)
-      this.keccak();
-    state[blockLen - 1] ^= 128;
-    this.keccak();
-  }
-  writeInto(out) {
-    aexists(this, false);
-    abytes(out);
-    this.finish();
-    const bufferOut = this.state;
-    const { blockLen } = this;
-    for (let pos = 0, len = out.length; pos < len; ) {
-      if (this.posOut >= blockLen)
-        this.keccak();
-      const take = Math.min(blockLen - this.posOut, len - pos);
-      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-      this.posOut += take;
-      pos += take;
-    }
-    return out;
-  }
-  xofInto(out) {
-    if (!this.enableXOF)
-      throw new Error("XOF is not possible for this instance");
-    return this.writeInto(out);
-  }
-  xof(bytes) {
-    anumber(bytes);
-    return this.xofInto(new Uint8Array(bytes));
-  }
-  digestInto(out) {
-    aoutput(out, this);
-    if (this.finished)
-      throw new Error("digest() was already called");
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy() {
-    this.destroyed = true;
-    clean(this.state);
-  }
-  _cloneInto(to) {
-    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-    to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
-    to.state32.set(this.state32);
-    to.pos = this.pos;
-    to.posOut = this.posOut;
-    to.finished = this.finished;
-    to.rounds = rounds;
-    to.suffix = suffix;
-    to.outputLen = outputLen;
-    to.enableXOF = enableXOF;
-    to.destroyed = this.destroyed;
-    return to;
-  }
-};
-var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
-var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
-
-// src/wallet.ts
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function base58Encode(bytes) {
-  let leadingZeros = 0;
-  for (const byte of bytes) {
-    if (byte === 0) leadingZeros++;
-    else break;
-  }
-  let num = 0n;
-  for (const byte of bytes) {
-    num = num * 256n + BigInt(byte);
-  }
-  let encoded = "";
-  while (num > 0n) {
-    encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
-    num = num / 58n;
-  }
-  return BASE58_ALPHABET[0].repeat(leadingZeros) + encoded;
-}
-function deriveSecp256k1Seed(ed25519Seed) {
-  const hmac = createHmac("sha512", "secp256k1");
-  hmac.update(ed25519Seed);
-  return hmac.digest().subarray(0, 32);
-}
-function getSecp256k1PublicKey(privateKey) {
-  const ecdh = createECDH("secp256k1");
-  ecdh.setPrivateKey(privateKey);
-  return Buffer.from(ecdh.getPublicKey());
-}
-function evmAddressFromPublicKey(uncompressedPubKey) {
-  const pubKeyBody = uncompressedPubKey.subarray(1);
-  const hash = keccak_256(pubKeyBody);
-  const addressBytes = hash.slice(hash.length - 20);
-  return "0x" + Buffer.from(addressBytes).toString("hex");
-}
-function checksumAddress(address) {
-  const addr = address.slice(2).toLowerCase();
-  const hash = Buffer.from(keccak_256(Buffer.from(addr, "utf-8"))).toString(
-    "hex"
-  );
-  let checksummed = "0x";
-  for (let i = 0; i < addr.length; i++) {
-    checksummed += parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
-  }
-  return checksummed;
-}
-async function getSolanaAddress(nitDir) {
-  const pubBase64 = await loadPublicKey(nitDir);
-  const pubBytes = Buffer.from(pubBase64, "base64");
-  return base58Encode(pubBytes);
-}
-async function getEvmAddress(nitDir) {
-  const keyPath = join5(nitDir, "identity", "agent.key");
-  const privBase64 = (await fs5.readFile(keyPath, "utf-8")).trim();
-  const ed25519Seed = Buffer.from(privBase64, "base64");
-  const secp256k1PrivKey = deriveSecp256k1Seed(ed25519Seed);
-  const secp256k1PubKey = getSecp256k1PublicKey(secp256k1PrivKey);
-  const rawAddress = evmAddressFromPublicKey(secp256k1PubKey);
-  return checksumAddress(rawAddress);
-}
-async function getWalletAddresses(nitDir) {
-  const [solana, ethereum] = await Promise.all([
-    getSolanaAddress(nitDir),
-    getEvmAddress(nitDir)
-  ]);
-  return { solana, ethereum };
-}
-async function loadSecp256k1RawKeyPair(nitDir) {
-  const keyPath = join5(nitDir, "identity", "agent.key");
-  const privBase64 = (await fs5.readFile(keyPath, "utf-8")).trim();
-  const ed25519Seed = Buffer.from(privBase64, "base64");
-  const secp256k1PrivKey = deriveSecp256k1Seed(ed25519Seed);
-  const secp256k1PubKey = getSecp256k1PublicKey(secp256k1PrivKey);
-  const keypair = new Uint8Array(64);
-  keypair.set(secp256k1PrivKey, 0);
-  keypair.set(secp256k1PubKey.subarray(1, 33), 32);
-  return keypair;
-}
-
-// src/diff.ts
-function diffCards(oldCard, newCard) {
-  const fields = [];
-  const scalarFields = [
-    "protocolVersion",
-    "name",
-    "description",
-    "version",
-    "url",
-    "publicKey",
-    "iconUrl",
-    "documentationUrl"
-  ];
-  for (const field of scalarFields) {
-    const oldVal = oldCard[field];
-    const newVal = newCard[field];
-    if (oldVal !== newVal) {
-      fields.push({ field, old: oldVal, new: newVal });
-    }
-  }
-  const oldProvider = JSON.stringify(oldCard.provider ?? null);
-  const newProvider = JSON.stringify(newCard.provider ?? null);
-  if (oldProvider !== newProvider) {
-    fields.push({ field: "provider", old: oldCard.provider, new: newCard.provider });
-  }
-  const arrayFields = [
-    "defaultInputModes",
-    "defaultOutputModes"
-  ];
-  for (const field of arrayFields) {
-    const oldArr = JSON.stringify(oldCard[field]);
-    const newArr = JSON.stringify(newCard[field]);
-    if (oldArr !== newArr) {
-      fields.push({ field, old: oldCard[field], new: newCard[field] });
-    }
-  }
-  const oldSkillMap = new Map(oldCard.skills.map((s) => [s.id, s]));
-  const newSkillMap = new Map(newCard.skills.map((s) => [s.id, s]));
-  const skillsAdded = [];
-  const skillsRemoved = [];
-  const skillsModified = [];
-  for (const [id] of newSkillMap) {
-    if (!oldSkillMap.has(id)) {
-      skillsAdded.push(id);
-    }
-  }
-  for (const [id] of oldSkillMap) {
-    if (!newSkillMap.has(id)) {
-      skillsRemoved.push(id);
-    }
-  }
-  for (const [id, newSkill] of newSkillMap) {
-    const oldSkill = oldSkillMap.get(id);
-    if (oldSkill && !skillsEqual(oldSkill, newSkill)) {
-      skillsModified.push(id);
-    }
-  }
-  const changed = fields.length > 0 || skillsAdded.length > 0 || skillsRemoved.length > 0 || skillsModified.length > 0;
-  return { changed, fields, skillsAdded, skillsRemoved, skillsModified };
-}
-function formatDiff(diff2) {
-  if (!diff2.changed) {
-    return "No changes.";
-  }
-  const lines = [];
-  for (const fd of diff2.fields) {
-    const oldStr = formatValue(fd.old);
-    const newStr = formatValue(fd.new);
-    lines.push(`  ${fd.field}:`);
-    lines.push(`\x1B[31m    - ${oldStr}\x1B[0m`);
-    lines.push(`\x1B[32m    + ${newStr}\x1B[0m`);
-  }
-  for (const id of diff2.skillsAdded) {
-    lines.push(`\x1B[32m  + skill: ${id}\x1B[0m`);
-  }
-  for (const id of diff2.skillsRemoved) {
-    lines.push(`\x1B[31m  - skill: ${id}\x1B[0m`);
-  }
-  for (const id of diff2.skillsModified) {
-    lines.push(`\x1B[33m  ~ skill: ${id} (modified)\x1B[0m`);
-  }
-  return lines.join("\n");
-}
-function skillsEqual(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-function formatValue(val) {
-  if (val === void 0) return "(unset)";
-  if (val === null) return "(null)";
-  if (typeof val === "string") return val;
-  return JSON.stringify(val);
-}
-
-// src/remote.ts
-import { createHash as createHash3 } from "crypto";
-function sha256Hex(data) {
-  return createHash3("sha256").update(data, "utf-8").digest("hex");
-}
-async function buildAuthHeaders(nitDir, method, path, body) {
-  const agentId = await loadAgentId(nitDir);
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
-  let message = `${method}
-${path}
-${agentId}
-${timestamp}`;
-  if (body !== void 0) {
-    message += `
-${sha256Hex(body)}`;
-  }
-  const signature = await signMessage(nitDir, message);
-  return {
-    "X-Nit-Agent-Id": agentId,
-    "X-Nit-Timestamp": timestamp,
-    "X-Nit-Signature": signature
-  };
-}
-async function pushBranch(nitDir, apiBase, branch2, cardJson, commitHash) {
-  const path = `/agent-card/branches/${encodeURIComponent(branch2)}`;
-  const body = JSON.stringify({ card_json: cardJson, commit_hash: commitHash });
-  try {
-    const authHeaders = await buildAuthHeaders(nitDir, "PUT", path, body);
-    const res = await fetch(`${apiBase}${path}`, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/json",
-        ...authHeaders
-      },
-      body
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      return {
-        branch: branch2,
-        commitHash,
-        remoteUrl: apiBase,
-        success: false,
-        error: `HTTP ${res.status}: ${text}`
-      };
-    }
-    return { branch: branch2, commitHash, remoteUrl: apiBase, success: true };
-  } catch (err) {
-    return {
-      branch: branch2,
-      commitHash,
-      remoteUrl: apiBase,
-      success: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-async function fetchBranchCard(cardUrl, branch2, nitDir) {
-  const baseUrl = cardUrl.replace(/\/$/, "");
-  let url = `${baseUrl}/.well-known/agent-card.json`;
-  if (branch2 !== "main") {
-    url += `?branch=${encodeURIComponent(branch2)}`;
-  }
-  const res = await fetch(url);
-  if (res.ok) {
-    return await res.json();
-  }
-  if (res.status === 401 && branch2 !== "main") {
-    if (!nitDir) {
-      throw new Error(
-        `Branch "${branch2}" requires authentication. Provide nitDir for signing.`
-      );
-    }
-    const challengeData = await res.json();
-    const signature = await signChallenge(nitDir, challengeData.challenge);
-    const authRes = await fetch(url, {
-      headers: {
-        "X-Nit-Challenge": challengeData.challenge,
-        "X-Nit-Signature": signature
-      }
-    });
-    if (!authRes.ok) {
-      const body = await authRes.text();
-      throw new Error(
-        `Failed to fetch branch "${branch2}" after challenge: HTTP ${authRes.status} ${body}`
-      );
-    }
-    return await authRes.json();
-  }
-  throw new Error(`Failed to fetch card: HTTP ${res.status}`);
-}
-
-// src/config.ts
-import { promises as fs6 } from "fs";
-import { join as join6 } from "path";
-var CONFIG_FILE = "config";
-async function readConfig(nitDir) {
-  const configPath = join6(nitDir, CONFIG_FILE);
-  let raw;
-  try {
-    raw = await fs6.readFile(configPath, "utf-8");
-  } catch {
-    return { remotes: {} };
-  }
-  return parseConfig(raw);
-}
-async function writeConfig(nitDir, config) {
-  const configPath = join6(nitDir, CONFIG_FILE);
-  await fs6.writeFile(configPath, serializeConfig(config), "utf-8");
-}
-async function getRemoteUrl(nitDir, remoteName) {
-  const config = await readConfig(nitDir);
-  return config.remotes[remoteName]?.url ?? null;
-}
-async function getSkillsDir(nitDir) {
-  const config = await readConfig(nitDir);
-  return config.skillsDir ?? null;
-}
-function parseConfig(raw) {
-  const remotes = {};
-  let currentSection = null;
-  let currentRemote = null;
-  let skillsDir;
-  for (const line of raw.split("\n")) {
-    const trimmed = line.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) continue;
-    const remoteMatch = trimmed.match(/^\[remote\s+"([^"]+)"\]$/);
-    if (remoteMatch) {
-      currentSection = "remote";
-      currentRemote = remoteMatch[1];
-      if (!remotes[currentRemote]) {
-        remotes[currentRemote] = {};
-      }
-      continue;
-    }
-    if (trimmed === "[skills]") {
-      currentSection = "skills";
-      currentRemote = null;
-      continue;
-    }
-    const kvMatch = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
-    if (kvMatch) {
-      const [, key, value] = kvMatch;
-      if (currentSection === "remote" && currentRemote !== null) {
-        if (key === "url") {
-          remotes[currentRemote].url = value.trim();
-        } else if (key === "credential") {
-          remotes[currentRemote].credential = value.trim();
-        }
-      } else if (currentSection === "skills") {
-        if (key === "dir") {
-          skillsDir = value.trim();
-        }
-      }
-    }
-  }
-  return { remotes, skillsDir };
-}
-function serializeConfig(config) {
-  const lines = [];
-  for (const [name, remote2] of Object.entries(config.remotes)) {
-    lines.push(`[remote "${name}"]`);
-    if (remote2.url) {
-      lines.push(`  url = ${remote2.url}`);
-    }
-    if (remote2.credential) {
-      lines.push(`  credential = ${remote2.credential}`);
-    }
-    lines.push("");
-  }
-  if (config.skillsDir) {
-    lines.push("[skills]");
-    lines.push(`  dir = ${config.skillsDir}`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-// src/index.ts
-var NIT_DIR = ".nit";
-var CARD_FILE = "agent-card.json";
-var DEFAULT_API_BASE = "https://api.newtype-ai.org";
-function findNitDir(startDir) {
-  let dir = resolve2(startDir || process.cwd());
-  while (true) {
-    const candidate = join7(dir, NIT_DIR);
-    try {
-      const s = statSync(candidate);
-      if (s.isDirectory()) return candidate;
-    } catch {
-    }
-    const parent = resolve2(dir, "..");
-    if (parent === dir) {
-      throw new Error(
-        "Not a nit repository (or any parent directory). Run `nit init` first."
-      );
-    }
-    dir = parent;
-  }
-}
-function projectDir(nitDir) {
-  return resolve2(nitDir, "..");
-}
-async function readWorkingCard(nitDir) {
-  const cardPath = join7(projectDir(nitDir), CARD_FILE);
-  try {
-    const raw = await fs7.readFile(cardPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    throw new Error(`Cannot read ${CARD_FILE}. Does it exist?`);
-  }
-}
-async function writeWorkingCard(nitDir, card) {
-  const cardPath = join7(projectDir(nitDir), CARD_FILE);
-  await fs7.writeFile(cardPath, JSON.stringify(card, null, 2) + "\n", "utf-8");
-}
-async function getCardAtCommit(nitDir, commitHash) {
-  const commitRaw = await readObject(nitDir, commitHash);
-  const commit2 = parseCommit(commitHash, commitRaw);
-  const cardRaw = await readObject(nitDir, commit2.card);
-  return JSON.parse(cardRaw);
-}
-async function getAuthorName(nitDir) {
-  try {
-    const card = await readWorkingCard(nitDir);
-    return card.name || basename2(projectDir(nitDir));
-  } catch {
-    return basename2(projectDir(nitDir));
-  }
-}
-async function init(options) {
-  const projDir = resolve2(options?.projectDir || process.cwd());
-  const nitDir = join7(projDir, NIT_DIR);
-  try {
-    await fs7.access(nitDir);
-    throw new Error("Already initialized. .nit/ directory exists.");
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith("Already")) throw err;
-  }
-  await fs7.mkdir(join7(nitDir, "objects"), { recursive: true });
-  await fs7.mkdir(join7(nitDir, "refs", "heads"), { recursive: true });
-  await fs7.mkdir(join7(nitDir, "refs", "remote"), { recursive: true });
-  await fs7.mkdir(join7(nitDir, "identity"), { recursive: true });
-  await fs7.mkdir(join7(nitDir, "logs"), { recursive: true });
-  const { publicKey: pubBase64 } = await generateKeypair(nitDir);
-  const publicKeyField = formatPublicKeyField(pubBase64);
-  const agentId = deriveAgentId(publicKeyField);
-  await saveAgentId(nitDir, agentId);
-  const cardPath = join7(projDir, CARD_FILE);
-  let card;
-  let skillsFound = [];
-  try {
-    const raw = await fs7.readFile(cardPath, "utf-8");
-    card = JSON.parse(raw);
-    card.publicKey = publicKeyField;
-    skillsFound = card.skills.map((s) => s.id);
-  } catch {
-    const discovered = await discoverSkills(projDir);
-    skillsFound = discovered.map((s) => s.id);
-    card = {
-      protocolVersion: "0.3.0",
-      name: basename2(projDir),
-      description: `AI agent working in ${basename2(projDir)}`,
-      version: "1.0.0",
-      url: "",
-      publicKey: publicKeyField,
-      defaultInputModes: ["text/plain"],
-      defaultOutputModes: ["text/plain"],
-      skills: discovered.map((s) => ({
-        id: s.id,
-        name: s.name,
-        description: s.description
-      }))
-    };
-  }
-  if (!card.url) {
-    card.url = `https://agent-${agentId}.newtype-ai.org`;
-  }
-  await writeWorkingCard(nitDir, card);
-  const cardJson = JSON.stringify(card, null, 2);
-  const cardHash = await writeObject(nitDir, "card", cardJson);
-  const commitContent = serializeCommit({
-    card: cardHash,
-    parent: null,
-    author: card.name,
-    timestamp: Math.floor(Date.now() / 1e3),
-    message: "Initial commit"
-  });
-  const commitHash = await writeObject(nitDir, "commit", commitContent);
-  await setBranch(nitDir, "main", commitHash);
-  await setHead(nitDir, "main");
-  await fs7.writeFile(join7(nitDir, "logs", "HEAD"), "", "utf-8");
-  const skillsDir = await discoverSkillsDir(projDir);
-  await writeConfig(nitDir, {
-    remotes: { origin: { url: DEFAULT_API_BASE } },
-    skillsDir
-  });
-  const walletAddresses = await getWalletAddresses(nitDir);
-  return {
-    agentId,
-    publicKey: publicKeyField,
-    cardUrl: card.url,
-    walletAddresses,
-    skillsFound,
-    skillsDir
-  };
-}
-async function status(options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const currentBranch = await getCurrentBranch(nitDir);
-  const pubBase64 = await loadPublicKey(nitDir);
-  const publicKey = formatPublicKeyField(pubBase64);
-  const agentId = await loadAgentId(nitDir);
-  const workingCard = await readWorkingCard(nitDir);
-  const cardUrl = workingCard.url || `https://agent-${agentId}.newtype-ai.org`;
-  let uncommittedChanges = null;
-  try {
-    const headHash = await resolveHead(nitDir);
-    const headCard = await getCardAtCommit(nitDir, headHash);
-    const workingCard2 = await readWorkingCard(nitDir);
-    const d = diffCards(headCard, workingCard2);
-    if (d.changed) {
-      uncommittedChanges = d;
-    }
-  } catch {
-  }
-  const branches = await listBranches(nitDir);
-  const branchStatus = [];
-  for (const b of branches) {
-    const remoteHash = await getRemoteRef(nitDir, "origin", b.name);
-    let ahead = 0;
-    if (remoteHash && remoteHash !== b.commitHash) {
-      let hash = b.commitHash;
-      while (hash && hash !== remoteHash) {
-        ahead++;
-        try {
-          const raw = await readObject(nitDir, hash);
-          const c = parseCommit(hash, raw);
-          hash = c.parent;
-        } catch {
-          break;
-        }
-      }
-    } else if (!remoteHash) {
-      let hash = b.commitHash;
-      while (hash) {
-        ahead++;
-        try {
-          const raw = await readObject(nitDir, hash);
-          const c = parseCommit(hash, raw);
-          hash = c.parent;
-        } catch {
-          break;
-        }
-      }
-    }
-    branchStatus.push({ name: b.name, ahead, behind: 0 });
-  }
-  const walletAddresses = await getWalletAddresses(nitDir);
-  return {
-    agentId,
-    cardUrl,
-    branch: currentBranch,
-    publicKey,
-    walletAddresses,
-    uncommittedChanges,
-    branches: branchStatus
-  };
-}
-async function sign2(message, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  return signMessage(nitDir, message);
-}
-async function loginPayload(domain, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  let switchedBranch;
-  let createdSkill;
-  const currentBranch = await getCurrentBranch(nitDir);
-  if (currentBranch !== domain) {
-    const isNew = !await getBranch(nitDir, domain);
-    if (isNew) {
-      const headHash = await resolveHead(nitDir);
-      await setBranch(nitDir, domain, headHash);
-    }
-    await checkout(domain, options);
-    switchedBranch = domain;
-  }
-  const projectDir2 = dirname2(nitDir);
-  const skillsDir = await getSkillsDir(nitDir) ?? await discoverSkillsDir(projectDir2);
-  if (skillsDir) {
-    const skillId = await createSkillTemplate(skillsDir, domain);
-    const card = await readWorkingCard(nitDir);
-    if (!card.skills.some((s) => s.id === skillId)) {
-      card.skills.push({ id: skillId });
-      await writeWorkingCard(nitDir, card);
-      createdSkill = skillId;
-    }
-  }
-  const agentId = await loadAgentId(nitDir);
-  const timestamp = Math.floor(Date.now() / 1e3);
-  const message = `${agentId}
-${domain}
-${timestamp}`;
-  const signature = await signMessage(nitDir, message);
-  return { agent_id: agentId, domain, timestamp, signature, switchedBranch, createdSkill };
-}
-async function commit(message, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const projDir = projectDir(nitDir);
-  let card = await readWorkingCard(nitDir);
-  card = await resolveSkillPointers(card, projDir);
-  const pubBase64 = await loadPublicKey(nitDir);
-  card.publicKey = formatPublicKeyField(pubBase64);
-  await writeWorkingCard(nitDir, card);
-  const cardJson = JSON.stringify(card, null, 2);
-  const cardHash = await writeObject(nitDir, "card", cardJson);
-  const currentBranch = await getCurrentBranch(nitDir);
-  const parentHash = await getBranch(nitDir, currentBranch);
-  if (parentHash) {
-    const parentRaw = await readObject(nitDir, parentHash);
-    const parentCommit = parseCommit(parentHash, parentRaw);
-    if (parentCommit.card === cardHash) {
-      throw new Error("Nothing to commit \u2014 agent card is unchanged.");
-    }
-  }
-  const author = await getAuthorName(nitDir);
-  const commitContent = serializeCommit({
-    card: cardHash,
-    parent: parentHash,
-    author,
-    timestamp: Math.floor(Date.now() / 1e3),
-    message
-  });
-  const commitHash = await writeObject(nitDir, "commit", commitContent);
-  await setBranch(nitDir, currentBranch, commitHash);
-  return {
-    type: "commit",
-    hash: commitHash,
-    card: cardHash,
-    parent: parentHash,
-    author,
-    timestamp: Math.floor(Date.now() / 1e3),
-    message
-  };
-}
-async function log(options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const currentBranch = await getCurrentBranch(nitDir);
-  let hash = await getBranch(nitDir, currentBranch);
-  const commits = [];
-  const limit = options?.count ?? 50;
-  while (hash && commits.length < limit) {
-    const raw = await readObject(nitDir, hash);
-    const c = parseCommit(hash, raw);
-    commits.push(c);
-    hash = c.parent;
-  }
-  return commits;
-}
-async function diff(target, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  if (!target) {
-    const headHash2 = await resolveHead(nitDir);
-    const headCard2 = await getCardAtCommit(nitDir, headHash2);
-    const workingCard = await readWorkingCard(nitDir);
-    return diffCards(headCard2, workingCard);
-  }
-  const targetBranchHash = await getBranch(nitDir, target);
-  const headHash = await resolveHead(nitDir);
-  const headCard = await getCardAtCommit(nitDir, headHash);
-  if (targetBranchHash) {
-    const targetCard = await getCardAtCommit(nitDir, targetBranchHash);
-    return diffCards(headCard, targetCard);
-  }
-  if (/^[0-9a-f]{64}$/.test(target)) {
-    const targetCard = await getCardAtCommit(nitDir, target);
-    return diffCards(headCard, targetCard);
-  }
-  throw new Error(
-    `Unknown target "${target}". Provide a branch name or commit hash.`
-  );
-}
-async function branch(name, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  if (name) {
-    const existing = await getBranch(nitDir, name);
-    if (existing) {
-      throw new Error(`Branch "${name}" already exists.`);
-    }
-    const headHash = await resolveHead(nitDir);
-    await setBranch(nitDir, name, headHash);
-  }
-  return listBranches(nitDir);
-}
-async function checkout(branchName, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  try {
-    const headHash = await resolveHead(nitDir);
-    const headCard = await getCardAtCommit(nitDir, headHash);
-    const workingCard = await readWorkingCard(nitDir);
-    const d = diffCards(headCard, workingCard);
-    if (d.changed) {
-      throw new Error(
-        "You have uncommitted changes. Commit or discard them before switching branches."
-      );
-    }
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("uncommitted changes")) {
-      throw err;
-    }
-  }
-  const targetHash = await getBranch(nitDir, branchName);
-  if (!targetHash) {
-    throw new Error(`Branch "${branchName}" does not exist.`);
-  }
-  const targetCard = await getCardAtCommit(nitDir, targetHash);
-  await writeWorkingCard(nitDir, targetCard);
-  await setHead(nitDir, branchName);
-}
-async function push(options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const remoteName = options?.remoteName || "origin";
-  const apiBase = await getRemoteUrl(nitDir, remoteName) || DEFAULT_API_BASE;
-  const branches = await listBranches(nitDir);
-  const currentBranch = await getCurrentBranch(nitDir);
-  const toPush = options?.all ? branches : branches.filter((b) => b.name === currentBranch);
-  if (toPush.length === 0) {
-    throw new Error("No branches to push.");
-  }
-  const results = [];
-  for (const b of toPush) {
-    const commitRaw = await readObject(nitDir, b.commitHash);
-    const c = parseCommit(b.commitHash, commitRaw);
-    const cardJson = await readObject(nitDir, c.card);
-    const result = await pushBranch(
-      nitDir,
-      apiBase,
-      b.name,
-      cardJson,
-      b.commitHash
-    );
-    if (result.success) {
-      await setRemoteRef(nitDir, remoteName, b.name, b.commitHash);
-    }
-    results.push(result);
-  }
-  return results;
-}
-async function remote(options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const remoteUrl = await getRemoteUrl(nitDir, "origin");
-  const agentId = await loadAgentId(nitDir);
-  return {
-    name: "origin",
-    url: remoteUrl || DEFAULT_API_BASE,
-    agentId
-  };
-}
-async function remoteAdd(name, url, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const config = await readConfig(nitDir);
-  if (config.remotes[name]) {
-    throw new Error(
-      `Remote "${name}" already exists. Use 'nit remote set-url ${name} <url>' to change it.`
-    );
-  }
-  config.remotes[name] = { url };
-  await writeConfig(nitDir, config);
-}
-async function remoteSetUrl(name, url, options) {
-  const nitDir = findNitDir(options?.projectDir);
-  const config = await readConfig(nitDir);
-  if (!config.remotes[name]) {
-    throw new Error(
-      `Remote "${name}" does not exist. Use 'nit remote add ${name} <url>' to create it.`
-    );
-  }
-  config.remotes[name].url = url;
-  await writeConfig(nitDir, config);
-}
-
-export {
-  loadRawKeyPair,
-  formatPublicKeyField,
-  parsePublicKeyField,
-  signChallenge,
-  signMessage,
-  NIT_NAMESPACE,
-  deriveAgentId,
-  loadAgentId,
-  base58Encode,
-  getSolanaAddress,
-  getEvmAddress,
-  getWalletAddresses,
-  loadSecp256k1RawKeyPair,
-  diffCards,
-  formatDiff,
-  fetchBranchCard,
-  findNitDir,
-  init,
-  status,
-  sign2 as sign,
-  loginPayload,
-  commit,
-  log,
-  diff,
-  branch,
-  checkout,
-  push,
-  remote,
-  remoteAdd,
-  remoteSetUrl
-};
-/*! Bundled license information:
-
-@noble/hashes/utils.js:
-  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
-*/