@hasna/skills 0.1.59 → 0.1.61

package/bin/worker.js

@@ -9724,7 +9724,7 @@ var require_es5 = __commonJS((exports, module) => {
 
 // node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/home/hasna/.hasna/repos/worktrees/skills-release-0159/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/tmp/cossus-skills-release-85552597/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var { Retry, RETRY_MODES } = require_retry();
   var { HttpRequest, parseUrl } = require_protocols();
   var { InvokeStore } = require_invoke_store();
@@ -20671,7 +20671,7 @@ var init_dist_es9 = __esm(() => {
 });
 
 // src/server/worker.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // node_modules/@aws-sdk/checksums/dist-cjs/submodules/flexible-checksums/index.js
 var { setFeature } = require_client2();
@@ -30259,6 +30259,10 @@ class S3Client extends import_client24.Client {
   }
 }
 
+// node_modules/@aws-sdk/client-s3/dist-es/commands/DeleteObjectCommand.js
+class DeleteObjectCommand extends command(_ep0, _mw0, "DeleteObject", DeleteObject$) {
+}
+
 // node_modules/@aws-sdk/client-s3/dist-es/commands/GetObjectCommand.js
 class GetObjectCommand extends command(_ep0, _mw7, "GetObject", GetObject$) {
 }
@@ -30267,7 +30271,137 @@ class GetObjectCommand extends command(_ep0, _mw7, "GetObject", GetObject$) {
 class PutObjectCommand extends command(_ep0, _mw11, "PutObject", PutObject$) {
 }
 
+// src/lib/skill-bundle.ts
+var ANY_SEGMENT_EXCLUDES = new Set([
+  ".git",
+  ".ds_store",
+  ".system",
+  "node_modules",
+  ".aws",
+  ".ssh",
+  ".gnupg",
+  ".docker"
+]);
+var ROOT_EXCLUDES = new Set(["dist", "build", ".turbo"]);
+var CREDENTIAL_FILENAMES = new Set([
+  ".npmrc",
+  ".pypirc",
+  ".netrc",
+  ".envrc",
+  ".pgpass",
+  ".git-credentials",
+  "credentials",
+  "id_rsa",
+  "id_dsa",
+  "id_ecdsa",
+  "id_ed25519"
+]);
+var ENV_TEMPLATE_NAMES = new Set([".env.example", ".env.sample", ".env.template", ".env.dist"]);
+var NON_DOTENV_EXTENSIONS = new Set([
+  "ts",
+  "tsx",
+  "mts",
+  "cts",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "json",
+  "jsonc",
+  "json5",
+  "py",
+  "rb",
+  "go",
+  "rs",
+  "java",
+  "kt",
+  "kts",
+  "swift",
+  "c",
+  "h",
+  "cc",
+  "cpp",
+  "hpp",
+  "cs",
+  "php",
+  "sh",
+  "bash",
+  "zsh",
+  "fish",
+  "ps1",
+  "bat",
+  "cmd",
+  "lua",
+  "pl",
+  "pm",
+  "r",
+  "jl",
+  "dart",
+  "ex",
+  "exs",
+  "scala",
+  "clj",
+  "cljs",
+  "groovy",
+  "gradle",
+  "vb",
+  "fs",
+  "yaml",
+  "yml",
+  "toml",
+  "ini",
+  "xml",
+  "csv",
+  "tsv",
+  "html",
+  "htm",
+  "css",
+  "scss",
+  "sass",
+  "less",
+  "md",
+  "mdx",
+  "txt",
+  "rst",
+  "adoc",
+  "sql",
+  "graphql",
+  "gql",
+  "proto",
+  "d",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "svg",
+  "webp",
+  "ico",
+  "bmp",
+  "pdf",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "mp3",
+  "mp4",
+  "wav",
+  "webm",
+  "zip",
+  "gz",
+  "tar",
+  "wasm"
+]);
+function ownBytes(view) {
+  const source = view instanceof ArrayBuffer ? new Uint8Array(view) : view;
+  const out = new Uint8Array(new ArrayBuffer(source.byteLength));
+  out.set(source);
+  return out;
+}
+
 // src/server/artifact-storage.ts
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+
 class ArtifactStorage {
   bucket;
   prefix;
@@ -30312,10 +30446,74 @@ class ArtifactStorage {
     }));
     return await bodyToText(response.Body);
   }
+  async putBundle(orgId, sha256, bytes, contentType = "application/gzip") {
+    assertSha256(sha256);
+    if (!this.bucket)
+      return { storageKind: "db", bytes };
+    const key = this.bundleKeyFor(orgId, sha256);
+    await this.s3.send(new PutObjectCommand({
+      Bucket: this.bucket,
+      Key: key,
+      Body: bytes,
+      ContentType: contentType
+    }));
+    return { storageKind: "s3", storageKey: key };
+  }
+  async readBundle(bundle) {
+    if (bundle.storageKind === "db")
+      return bundle.bytes ?? null;
+    if (!this.bucket || !this.s3 || !bundle.storageKey)
+      return null;
+    const response = await this.s3.send(new GetObjectCommand({
+      Bucket: this.bucket,
+      Key: bundle.storageKey
+    }));
+    return await bodyToBytes(response.Body);
+  }
+  async deleteBundle(orgId, sha256) {
+    if (!this.bucket || !this.s3)
+      return;
+    assertSha256(sha256);
+    await this.s3.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: this.bundleKeyFor(orgId, sha256) }));
+  }
   keyFor(run, relativePath) {
     const safeRelativePath = relativePath.replace(/^\/+/, "").replace(/\.\.(?:\/|$)/g, "");
     return `${this.prefix}/${run.orgId}/${run.id}/${safeRelativePath}`;
   }
+  bundleKeyFor(orgId, sha256) {
+    return `${this.prefix}/bundles/${encodeURIComponent(orgId)}/${sha256}.tar.gz`;
+  }
+}
+function assertSha256(value) {
+  if (!SHA256_HEX.test(value)) {
+    throw new Error("bundle digest must be a lowercase hex sha-256; refusing to build a storage key from it");
+  }
+}
+async function bodyToBytes(body) {
+  if (!body)
+    return ownBytes(new Uint8Array(0));
+  if (body instanceof Uint8Array)
+    return ownBytes(body);
+  if (typeof body.transformToByteArray === "function") {
+    return ownBytes(await body.transformToByteArray());
+  }
+  if (typeof body.getReader === "function") {
+    const reader = body.getReader();
+    const chunks2 = [];
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      if (value)
+        chunks2.push(value);
+    }
+    return concat(chunks2);
+  }
+  const chunks = [];
+  for await (const chunk of body) {
+    chunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+  }
+  return concat(chunks);
 }
 async function bodyToText(body) {
   if (!body)
@@ -30347,7 +30545,7 @@ async function bodyToText(body) {
 }
 function concat(chunks) {
   const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
-  const merged = new Uint8Array(total);
+  const merged = new Uint8Array(new ArrayBuffer(total));
   let offset = 0;
   for (const chunk of chunks) {
     merged.set(chunk, offset);
@@ -30356,23 +30554,89 @@ function concat(chunks) {
   return merged;
 }
 
+// src/server/auth.ts
+import { createHash as createHash3 } from "crypto";
+function hashApiKey(token) {
+  return createHash3("sha256").update(token).digest("hex");
+}
+function publicPrincipal(partial = {}) {
+  return {
+    apiKeyId: partial.apiKeyId || "key_dev",
+    orgId: partial.orgId || "org_dev",
+    orgSlug: partial.orgSlug || "dev",
+    orgName: partial.orgName || "Development",
+    userId: partial.userId || "user_dev",
+    email: partial.email || "dev@example.com",
+    role: partial.role || "owner",
+    scopes: partial.scopes || ["skills:read", "runs:write"]
+  };
+}
+
+// src/lib/retired-settings.ts
+var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
+class RetiredSettingError extends Error {
+  code = "RETIRED_SETTING";
+  setting;
+  constructor(setting, message) {
+    super(message);
+    this.name = "RetiredSettingError";
+    this.setting = setting;
+  }
+}
+function isRetiredModeEnvVar(name, app) {
+  const upper = name.toUpperCase();
+  if (!upper.includes(app.toUpperCase()))
+    return false;
+  return RETIRED_ENV_SUFFIXES.some((suffix) => upper.endsWith(suffix));
+}
+function findRetiredModeEnvVars(env, app) {
+  const found = [];
+  for (const [name, value] of Object.entries(env)) {
+    if (value === undefined || value === "")
+      continue;
+    if (isRetiredModeEnvVar(name, app))
+      found.push({ name, value });
+  }
+  return found.sort((a3, b3) => a3.name.localeCompare(b3.name));
+}
+function assertNoRetiredModeEnvVars(env, options) {
+  const found = findRetiredModeEnvVars(env, options.app);
+  if (found.length === 0)
+    return;
+  const names = found.map((entry) => entry.name);
+  throw new RetiredSettingError(names[0], `${names.join(", ")} ${names.length === 1 ? "is" : "are"} no longer read. ` + "Deployment modes were removed: where a server keeps its data is decided by the " + `database it is given, not by a declared label. Set ${options.replacement} to a ` + "postgres:// URL to use PostgreSQL, or leave it unset for the on-box SQLite database. " + `Then unset ${names.join(" and ")}. ` + "Refused rather than ignored, because a discarded setting looks exactly like a " + "working one until something needs the data.");
+}
+
 // src/server/config.ts
-var DEFAULT_SELF_HOSTED_API_URL = "https://skills.md";
+var DATABASE_URL_ENV = "HASNA_SKILLS_DATABASE_URL";
+var SKILLS_ENV_NAMESPACE = "SKILLS";
 function resolveServerConfig(env = process.env) {
+  assertNoRetiredModeEnvVars(env, {
+    app: SKILLS_ENV_NAMESPACE,
+    replacement: DATABASE_URL_ENV
+  });
   const nodeEnv = env.NODE_ENV || "development";
+  const host = env.HOST || env.SKILLS_HOST || "0.0.0.0";
+  const port = parsePositiveInt(env.PORT || env.SKILLS_PORT, 8787);
   return {
-    host: env.HOST || env.SKILLS_HOST || "0.0.0.0",
-    port: parsePositiveInt(env.PORT || env.SKILLS_PORT, 8787),
-    databaseUrl: env.HASNA_SKILLS_DATABASE_URL || env.DATABASE_URL || undefined,
+    host,
+    port,
+    databaseUrl: env[DATABASE_URL_ENV] || env.DATABASE_URL || undefined,
     bootstrapApiKey: env.HASNA_SKILLS_BOOTSTRAP_API_KEY || undefined,
     artifactBucket: env.HASNA_SKILLS_S3_BUCKET || env.SKILLS_S3_BUCKET || undefined,
     artifactPrefix: normalizePrefix(env.HASNA_SKILLS_S3_PREFIX || env.SKILLS_S3_PREFIX || "skills/artifacts"),
     inlineWorker: env.HASNA_SKILLS_INLINE_WORKER === "1",
     requestBodyLimitBytes: parsePositiveInt(env.HASNA_SKILLS_REQUEST_BODY_LIMIT_BYTES, 1e6),
-    publicBaseUrl: (env.SKILLS_PUBLIC_BASE_URL || DEFAULT_SELF_HOSTED_API_URL).replace(/\/+$/, ""),
-    nodeEnv
+    skillBundleLimitBytes: parsePositiveInt(env.HASNA_SKILLS_BUNDLE_LIMIT_BYTES, 25000000),
+    publicBaseUrl: (env.SKILLS_PUBLIC_BASE_URL || localOrigin(host, port)).replace(/\/+$/, ""),
+    nodeEnv,
+    allowEphemeralStore: env.HASNA_SKILLS_ALLOW_EPHEMERAL_STORE === "1"
   };
 }
+function localOrigin(host, port) {
+  const hostname = host === "0.0.0.0" || host === "::" ? "localhost" : host;
+  return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`;
+}
 function parsePositiveInt(value, fallback) {
   const parsed = Number.parseInt(value ?? "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -30381,78 +30645,772 @@ function normalizePrefix(value) {
   return value.replace(/^\/+|\/+$/g, "") || "skills/artifacts";
 }
 
-// src/server/handlers.ts
-import { createHash as createHash4 } from "crypto";
+// src/server/database-url.ts
+import { isAbsolute, join as join3 } from "path";
+import { fileURLToPath } from "url";
 
-// src/server/store.ts
-import { randomUUID } from "crypto";
+// src/lib/config.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { homedir as homedir2 } from "os";
+function mergeDirectoryContents(sourceDir, targetDir) {
+  if (!existsSync(sourceDir))
+    return;
+  mkdirSync(targetDir, { recursive: true });
+  for (const entry of readdirSync(sourceDir)) {
+    const sourcePath = join2(sourceDir, entry);
+    const targetPath = join2(targetDir, entry);
+    try {
+      const sourceStat = statSync(sourcePath);
+      if (sourceStat.isDirectory()) {
+        mergeDirectoryContents(sourcePath, targetPath);
+        continue;
+      }
+      if (!existsSync(targetPath))
+        copyFileSync(sourcePath, targetPath);
+    } catch {}
+  }
+}
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+function getDataDir() {
+  const override = process.env[DATA_DIR_ENV];
+  if (override) {
+    try {
+      mkdirSync(override, { recursive: true });
+    } catch {}
+    return override;
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
+  const newDir = join2(home, ".hasna", "skills");
+  const oldDir = join2(home, ".skills");
+  const oldConfigFile = join2(home, ".skillsrc");
+  mkdirSync(newDir, { recursive: true });
+  try {
+    mergeDirectoryContents(oldDir, newDir);
+  } catch {}
+  if (existsSync(oldConfigFile) && !existsSync(join2(newDir, "config.json"))) {
+    try {
+      copyFileSync(oldConfigFile, join2(newDir, "config.json"));
+    } catch {}
+  }
+  return newDir;
+}
 
-// src/server/auth.ts
-import { createHash as createHash3 } from "crypto";
-function hashApiKey(token) {
-  return createHash3("sha256").update(token).digest("hex");
+// src/server/database-url.ts
+var DEFAULT_SQLITE_FILENAME = "server.db";
+var SQLITE_MEMORY_PATH = ":memory:";
+var POSTGRES_SCHEMES = new Set(["postgres", "postgresql"]);
+var SQLITE_SCHEMES = new Set(["sqlite", "sqlite3", "file"]);
+var MEMORY_SCHEMES = new Set(["memory"]);
+var SQLITE_EXTENSIONS = [".db", ".sqlite", ".sqlite3", ".db3"];
+function defaultSqlitePath() {
+  return join3(getDataDir(), DEFAULT_SQLITE_FILENAME);
 }
-function publicPrincipal(partial = {}) {
-  return {
-    apiKeyId: partial.apiKeyId || "key_dev",
-    orgId: partial.orgId || "org_dev",
-    orgSlug: partial.orgSlug || "dev",
-    orgName: partial.orgName || "Development",
-    userId: partial.userId || "user_dev",
-    email: partial.email || "dev@example.com",
-    role: partial.role || "owner",
-    scopes: partial.scopes || ["skills:read", "runs:write"]
-  };
+function resolveDatabaseTarget(raw) {
+  const value = raw?.trim();
+  if (!value) {
+    const path = defaultSqlitePath();
+    return { kind: "sqlite", path, durable: true, label: `sqlite (${path})` };
+  }
+  if (value === SQLITE_MEMORY_PATH) {
+    return { kind: "sqlite", path: SQLITE_MEMORY_PATH, durable: false, label: "sqlite (in-memory)" };
+  }
+  const schemeMatch = value.match(/^([a-z][a-z0-9+.-]+):/i);
+  const scheme = schemeMatch?.[1]?.toLowerCase();
+  if (scheme && POSTGRES_SCHEMES.has(scheme)) {
+    return { kind: "postgres", url: value, durable: true, label: "postgres" };
+  }
+  if (scheme && MEMORY_SCHEMES.has(scheme)) {
+    return { kind: "memory", durable: false, label: "memory (non-durable)" };
+  }
+  if (scheme && SQLITE_SCHEMES.has(scheme)) {
+    const path = sqlitePathFromUrl(value, scheme);
+    return path === SQLITE_MEMORY_PATH ? { kind: "sqlite", path, durable: false, label: "sqlite (in-memory)" } : { kind: "sqlite", path, durable: true, label: `sqlite (${path})` };
+  }
+  if (scheme) {
+    throw new Error(`unsupported database scheme "${scheme}:". Supported: postgres://, postgresql://, sqlite:, file:, ` + `an absolute or relative path to a .db/.sqlite file, ":memory:", or "memory:" (non-durable, tests only). ` + `Leave the setting empty to use the default SQLite database at ${defaultSqlitePath()}.`);
+  }
+  if (looksLikeSqlitePath(value)) {
+    const path = isAbsolute(value) ? value : join3(process.cwd(), value);
+    return { kind: "sqlite", path, durable: true, label: `sqlite (${path})` };
+  }
+  throw new Error(`could not resolve a database backend from "${value}". Use postgres://\u2026, sqlite:\u2026, an absolute or ` + `relative path ending in ${SQLITE_EXTENSIONS.join("/")}, ":memory:", or leave it empty for the ` + `default SQLite database at ${defaultSqlitePath()}.`);
 }
+function sqlitePathFromUrl(value, scheme) {
+  const rest = value.slice(scheme.length + 1).replace(/[?#].*$/, "");
+  if (rest.startsWith(SQLITE_MEMORY_PATH))
+    return SQLITE_MEMORY_PATH;
+  if (rest === "" || rest === "//") {
+    throw new Error(`"${value}" names no database file. Give a path (${scheme}:///var/lib/skills/server.db), ` + `or ":memory:" if a non-durable database is genuinely what you want. ` + "An empty path here usually means an unset variable in a templated URL.");
+  }
+  if (rest.startsWith("//")) {
+    if (!rest.startsWith("///")) {
+      const authority = rest.slice(2).split("/")[0];
+      throw new Error(`"${value}" has a host ("${authority}") where a path was expected. Remote SQLite files are not a thing; ` + `for an absolute path use ${scheme}:///${rest.slice(2)}, and for a relative one use ${scheme}:${rest.slice(2)}.`);
+    }
+    if (scheme === "file") {
+      try {
+        return fileURLToPath(new URL(value));
+      } catch {}
+    }
+    return rest.slice(2).replace(/^\/\/+/, "/");
+  }
+  return isAbsolute(rest) ? rest : join3(process.cwd(), rest);
+}
+function looksLikeSqlitePath(value) {
+  if (value.includes("/"))
+    return true;
+  return SQLITE_EXTENSIONS.some((extension) => value.toLowerCase().endsWith(extension));
+}
+
+// src/server/handlers.ts
+import { createHash as createHash4 } from "crypto";
 
 // src/server/store.ts
-function resolvePoolMax(env = process.env) {
-  const parsed = Number.parseInt(env.HASNA_SKILLS_DATABASE_POOL_MAX || env.SKILLS_DATABASE_POOL_MAX || "", 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 4;
-}
+import { randomUUID as randomUUID3 } from "crypto";
+
+// src/server/rows.ts
+import { randomUUID } from "crypto";
 function nowIso() {
   return new Date().toISOString();
 }
+function normalizeLimit(limit) {
+  return Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : 0;
+}
 function runId() {
   return `run_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
 }
 function artifactId() {
   return `art_${randomUUID().replace(/-/g, "").slice(0, 20)}`;
 }
-function createArtifactId() {
-  return artifactId();
+function rowToRun(row) {
+  return {
+    id: String(row.id),
+    orgId: String(row.org_id),
+    userId: String(row.user_id),
+    skill: String(row.skill_slug),
+    requestedSlug: String(row.requested_slug),
+    status: String(row.status),
+    input: parseJsonObject(row.input_json),
+    args: parseJsonArray(row.args_json),
+    ...typeof row.idempotency_key === "string" ? { idempotencyKey: row.idempotency_key } : {},
+    correlationId: String(row.correlation_id),
+    costCents: Number(row.cost_cents ?? 0),
+    ...typeof row.output_type === "string" ? { outputType: row.output_type } : {},
+    ...typeof row.output_preview === "string" ? { outputPreview: row.output_preview } : {},
+    ...typeof row.error_code === "string" ? { errorCode: row.error_code } : {},
+    ...typeof row.error_message === "string" ? { errorMessage: row.error_message } : {},
+    createdAt: dateString(row.created_at),
+    ...row.started_at ? { startedAt: dateString(row.started_at) } : {},
+    ...row.completed_at ? { completedAt: dateString(row.completed_at) } : {}
+  };
 }
-async function createStore(options = {}) {
-  const store = options.databaseUrl ? new PostgresSkillsStore(options.databaseUrl) : new MemorySkillsStore;
-  if (options.bootstrapApiKey && store.ensureBootstrapApiKey) {
-    await store.ensureBootstrapApiKey(options.bootstrapApiKey);
+function rowToLog(row) {
+  return {
+    runId: String(row.run_id),
+    sequence: Number(row.sequence),
+    level: String(row.level),
+    message: String(row.message),
+    createdAt: dateString(row.created_at)
+  };
+}
+function rowToArtifact(row) {
+  return {
+    id: String(row.id),
+    runId: String(row.run_id),
+    orgId: String(row.org_id),
+    fileName: String(row.file_name),
+    relativePath: String(row.relative_path),
+    contentType: String(row.content_type),
+    byteSize: Number(row.byte_size),
+    sha256: String(row.sha256),
+    storageKind: String(row.storage_kind),
+    ...typeof row.storage_key === "string" ? { storageKey: row.storage_key } : {},
+    ...typeof row.body_text === "string" ? { bodyText: row.body_text } : {},
+    createdAt: dateString(row.created_at)
+  };
+}
+function rowToSkill(row) {
+  return {
+    orgId: String(row.org_id),
+    slug: String(row.slug),
+    displayName: String(row.display_name),
+    description: String(row.description ?? ""),
+    category: String(row.category),
+    tags: parseJsonArray(row.tags_json),
+    source: String(row.source),
+    kind: String(row.kind) === "instruction" ? "instruction" : "executable",
+    ...typeof row.version === "string" ? { version: row.version } : {},
+    ...typeof row.skill_md === "string" ? { skillMd: row.skill_md } : {},
+    ...typeof row.bundle_sha256 === "string" ? { bundleSha256: row.bundle_sha256 } : {},
+    ...row.bundle_byte_size === null || row.bundle_byte_size === undefined ? {} : { bundleByteSize: Number(row.bundle_byte_size) },
+    ...typeof row.published_by_user_id === "string" ? { publishedByUserId: row.published_by_user_id } : {},
+    createdAt: dateString(row.created_at),
+    updatedAt: dateString(row.updated_at)
+  };
+}
+function rowToSkillBundle(row) {
+  return {
+    orgId: String(row.org_id),
+    sha256: String(row.sha256),
+    byteSize: Number(row.byte_size),
+    contentType: String(row.content_type),
+    storageKind: String(row.storage_kind),
+    ...typeof row.storage_key === "string" ? { storageKey: row.storage_key } : {},
+    ...toBytes(row.body_blob) ? { bytes: toBytes(row.body_blob) } : {},
+    createdAt: dateString(row.created_at)
+  };
+}
+function toBytes(value) {
+  if (value == null)
+    return null;
+  if (value instanceof Uint8Array)
+    return ownBytes(value);
+  if (value instanceof ArrayBuffer)
+    return ownBytes(value);
+  return null;
+}
+function parseJsonObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value))
+    return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {}
   }
-  return store;
+  return {};
+}
+function parseJsonArray(value) {
+  const parsed = typeof value === "string" ? safeParse(value) : value;
+  return Array.isArray(parsed) ? parsed.map(String) : [];
+}
+function safeParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+}
+function dateString(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  return String(value);
 }
 
-class MemorySkillsStore {
-  apiKeys = new Map;
-  runs = new Map;
-  logs = new Map;
-  artifacts = new Map;
-  idempotency = new Map;
-  constructor(apiKeys = []) {
-    for (const key of apiKeys)
-      this.addApiKey(key.token, key.principal);
+// src/server/sqlite-store.ts
+import { Database } from "bun:sqlite";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
+
+// src/server/migrations-dir.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+var MIGRATION_DIALECTS = ["postgres", "sqlite"];
+var MAX_WALK_UP = 6;
+function findMigrationsRoot(startDirs = defaultStartDirs()) {
+  for (const start of startDirs) {
+    let dir = start;
+    for (let level = 0;level < MAX_WALK_UP; level += 1) {
+      const candidate = join4(dir, "migrations");
+      if (MIGRATION_DIALECTS.some((dialect) => existsSync2(join4(candidate, dialect))))
+        return candidate;
+      const parent = dirname3(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
   }
-  addApiKey(token, principal) {
-    const resolved = publicPrincipal(principal);
-    this.apiKeys.set(hashApiKey(token), resolved);
-    return resolved;
+  return null;
+}
+function resolveMigrationsDir(dialect, root3 = findMigrationsRoot()) {
+  if (!root3) {
+    throw new Error(`could not locate the migrations directory for dialect "${dialect}". ` + `Expected a migrations/${dialect}/ folder alongside the package root.`);
+  }
+  const dir = join4(root3, dialect);
+  if (!existsSync2(dir)) {
+    throw new Error(`migrations directory not found: ${dir}`);
+  }
+  return dir;
+}
+function defaultStartDirs() {
+  const dirs = [import.meta.dir];
+  const cwd = process.cwd();
+  if (cwd && cwd !== import.meta.dir)
+    dirs.push(cwd);
+  return dirs;
+}
+
+// src/server/sqlite-store.ts
+var CLAIM_ATTEMPTS = 8;
+var CLAIMABLE_STATUSES = ["queued", "retrying"];
+var LAST_USED_RESOLUTION_MS = 60000;
+
+class SqliteSkillsStore {
+  backend;
+  db;
+  closed = false;
+  constructor(path = SQLITE_MEMORY_PATH, options = {}) {
+    const inMemory = path === SQLITE_MEMORY_PATH;
+    if (!inMemory)
+      mkdirSync2(dirname4(path), { recursive: true });
+    this.db = openDatabase(path);
+    this.db.exec(`PRAGMA busy_timeout = ${Math.max(0, options.busyTimeoutMs ?? 5000)}`);
+    if (!inMemory)
+      enableWalMode(this.db);
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.db.exec("PRAGMA synchronous = NORMAL");
+    if (options.migrate !== false) {
+      applySqliteMigrations(this.db, options.migrationsDir);
+    }
+    this.backend = {
+      kind: "sqlite",
+      durable: !inMemory,
+      label: inMemory ? "sqlite (in-memory)" : `sqlite (${path})`
+    };
+  }
+  get database() {
+    return this.db;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.db.close(false);
   }
   async ensureBootstrapApiKey(token, principal) {
-    this.addApiKey(token, principal);
+    const resolved = publicPrincipal(principal);
+    this.db.transaction(() => {
+      this.db.run(`INSERT INTO organizations (id, slug, name) VALUES (?, ?, ?)
+         ON CONFLICT (id) DO UPDATE SET slug = excluded.slug, name = excluded.name`, [resolved.orgId, resolved.orgSlug, resolved.orgName]);
+      this.db.run(`INSERT INTO users (id, email, name) VALUES (?, ?, ?)
+         ON CONFLICT (id) DO UPDATE SET email = excluded.email`, [resolved.userId, resolved.email, resolved.email]);
+      this.db.run(`INSERT INTO organization_members (org_id, user_id, role) VALUES (?, ?, ?)
+         ON CONFLICT (org_id, user_id) DO UPDATE SET role = excluded.role`, [resolved.orgId, resolved.userId, resolved.role]);
+      this.db.run(`INSERT INTO api_keys (id, org_id, user_id, name, key_hash, scopes_json)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT (key_hash) DO NOTHING`, [resolved.apiKeyId, resolved.orgId, resolved.userId, "bootstrap", hashApiKey(token), JSON.stringify(resolved.scopes)]);
+    })();
   }
   async authenticateApiKeyHash(hash) {
-    return this.apiKeys.get(hash) ?? null;
-  }
-  async createRun(input) {
-    const idemKey = input.idempotencyKey?.trim();
+    const row = this.get(`SELECT k.id AS api_key_id, k.scopes_json, k.last_used_at, o.id AS org_id, o.slug AS org_slug, o.name AS org_name,
+              u.id AS user_id, u.email, m.role
+       FROM api_keys k
+       JOIN organizations o ON o.id = k.org_id
+       JOIN users u ON u.id = k.user_id
+       LEFT JOIN organization_members m ON m.org_id = k.org_id AND m.user_id = k.user_id
+       WHERE k.key_hash = ? AND k.revoked_at IS NULL
+       LIMIT 1`, [hash]);
+    if (!row)
+      return null;
+    const lastUsed = typeof row.last_used_at === "string" ? Date.parse(row.last_used_at) : Number.NaN;
+    if (!Number.isFinite(lastUsed) || Date.now() - lastUsed >= LAST_USED_RESOLUTION_MS) {
+      this.db.run("UPDATE api_keys SET last_used_at = ? WHERE id = ?", [nowIso(), String(row.api_key_id)]);
+    }
+    return {
+      apiKeyId: String(row.api_key_id),
+      orgId: String(row.org_id),
+      orgSlug: String(row.org_slug),
+      orgName: String(row.org_name),
+      userId: String(row.user_id),
+      email: String(row.email),
+      role: typeof row.role === "string" ? row.role : "member",
+      scopes: parseScopes(row.scopes_json)
+    };
+  }
+  async createRun(input) {
+    if (input.idempotencyKey) {
+      const existing = this.get("SELECT * FROM skills_runs WHERE org_id = ? AND idempotency_key = ? LIMIT 1", [input.principal.orgId, input.idempotencyKey]);
+      if (existing)
+        return rowToRun(existing);
+    }
+    const row = this.get(`INSERT INTO skills_runs (id, org_id, user_id, skill_slug, requested_slug, status, input_json, args_json, idempotency_key, correlation_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`, [
+      runId(),
+      input.principal.orgId,
+      input.principal.userId,
+      input.slug,
+      input.slug,
+      "queued",
+      JSON.stringify(input.input),
+      JSON.stringify(input.args),
+      input.idempotencyKey ?? null,
+      randomUUID2(),
+      nowIso()
+    ]);
+    return rowToRun(row);
+  }
+  async listRuns(principal, limit) {
+    return this.all("SELECT * FROM skills_runs WHERE org_id = ? ORDER BY created_at DESC, rowid DESC LIMIT ?", [principal.orgId, normalizeLimit(limit)]).map(rowToRun);
+  }
+  async getRun(principal, id) {
+    const row = this.get("SELECT * FROM skills_runs WHERE id = ? AND org_id = ? LIMIT 1", [id, principal.orgId]);
+    return row ? rowToRun(row) : null;
+  }
+  async claimNextRun(input) {
+    const lost = new Set;
+    for (let attempt = 0;attempt < CLAIM_ATTEMPTS; attempt += 1) {
+      const claimed = this.claimOnce(input.workerId, lost);
+      if (claimed === "empty")
+        return null;
+      if (claimed)
+        return claimed;
+    }
+    return null;
+  }
+  claimOnce(workerId, lost) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const excluded = [...lost];
+      const candidate = this.get(`SELECT id FROM skills_runs
+         WHERE status IN (${CLAIMABLE_STATUSES.map(() => "?").join(", ")})
+           ${excluded.length ? `AND id NOT IN (${excluded.map(() => "?").join(", ")})` : ""}
+         ORDER BY created_at ASC, rowid ASC
+         LIMIT 1`, [...CLAIMABLE_STATUSES, ...excluded]);
+      if (!candidate) {
+        this.db.exec("COMMIT");
+        return "empty";
+      }
+      const id = String(candidate.id);
+      const now = nowIso();
+      const result = this.db.run(`UPDATE skills_runs
+         SET status = 'running', started_at = COALESCE(started_at, ?), locked_by = ?, locked_at = ?
+         WHERE id = ? AND status IN (${CLAIMABLE_STATUSES.map(() => "?").join(", ")})`, [now, workerId, now, id, ...CLAIMABLE_STATUSES]);
+      if (result.changes !== 1) {
+        this.db.exec("ROLLBACK");
+        lost.add(id);
+        return null;
+      }
+      const row = this.get("SELECT * FROM skills_runs WHERE id = ? LIMIT 1", [id]);
+      if (!row) {
+        this.db.exec("ROLLBACK");
+        throw new Error(`claimed run ${id} vanished within its own transaction; refusing to report a lost claim as an empty queue`);
+      }
+      this.db.exec("COMMIT");
+      return rowToRun(row);
+    } catch (error) {
+      this.rollbackQuietly();
+      throw error;
+    }
+  }
+  async updateRun(id, patch) {
+    const current = this.get("SELECT * FROM skills_runs WHERE id = ? LIMIT 1", [id]);
+    if (!current)
+      return null;
+    const run = { ...rowToRun(current), ...patch };
+    const row = this.get(`UPDATE skills_runs
+       SET status = ?, output_type = ?, output_preview = ?, error_code = ?, error_message = ?, started_at = ?, completed_at = ?
+       WHERE id = ?
+       RETURNING *`, [
+      run.status,
+      run.outputType ?? null,
+      run.outputPreview ?? null,
+      run.errorCode ?? null,
+      run.errorMessage ?? null,
+      run.startedAt ?? null,
+      run.completedAt ?? null,
+      id
+    ]);
+    return row ? rowToRun(row) : null;
+  }
+  async appendLog(id, orgId, level, message) {
+    const row = this.get(`INSERT INTO skills_run_logs (run_id, org_id, sequence, level, message, created_at)
+       VALUES (?, ?, (SELECT COALESCE(MAX(sequence), 0) + 1 FROM skills_run_logs WHERE run_id = ?), ?, ?, ?)
+       RETURNING *`, [id, orgId, id, level, message, nowIso()]);
+    return rowToLog(row);
+  }
+  async listLogs(principal, id) {
+    return this.all(`SELECT l.* FROM skills_run_logs l
+       JOIN skills_runs r ON r.id = l.run_id AND r.org_id = ?
+       WHERE l.run_id = ?
+       ORDER BY l.sequence ASC`, [principal.orgId, id]).map(rowToLog);
+  }
+  async addArtifact(artifact) {
+    const row = this.get(`INSERT INTO skills_artifacts (id, run_id, org_id, file_name, relative_path, content_type, byte_size, sha256, storage_kind, storage_key, body_text, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`, [
+      artifact.id,
+      artifact.runId,
+      artifact.orgId,
+      artifact.fileName,
+      artifact.relativePath,
+      artifact.contentType,
+      artifact.byteSize,
+      artifact.sha256,
+      artifact.storageKind,
+      artifact.storageKey ?? null,
+      artifact.bodyText ?? null,
+      nowIso()
+    ]);
+    return rowToArtifact(row);
+  }
+  async listArtifacts(principal, id) {
+    return this.all(`SELECT a.* FROM skills_artifacts a
+       JOIN skills_runs r ON r.id = a.run_id AND r.org_id = ?
+       WHERE a.run_id = ?
+       ORDER BY a.created_at ASC, a.rowid ASC`, [principal.orgId, id]).map(rowToArtifact);
+  }
+  async getArtifact(principal, id, artifact) {
+    const row = this.get(`SELECT a.* FROM skills_artifacts a
+       JOIN skills_runs r ON r.id = a.run_id AND r.org_id = ?
+       WHERE a.run_id = ? AND a.id = ?
+       LIMIT 1`, [principal.orgId, id, artifact]);
+    return row ? rowToArtifact(row) : null;
+  }
+  async publishSkill(input) {
+    const orgId = input.principal.orgId;
+    const now = nowIso();
+    return this.db.transaction(() => {
+      const previous = this.get("SELECT bundle_sha256 FROM skills_registry WHERE org_id = ? AND slug = ?", [orgId, input.slug]);
+      const previousSha = typeof previous?.bundle_sha256 === "string" ? previous.bundle_sha256 : null;
+      if (input.bundle) {
+        this.db.run(`INSERT INTO skills_bundles (org_id, sha256, byte_size, content_type, storage_kind, storage_key, body_blob, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (org_id, sha256) DO UPDATE SET
+             byte_size = excluded.byte_size,
+             content_type = excluded.content_type,
+             storage_kind = excluded.storage_kind,
+             storage_key = excluded.storage_key,
+             body_blob = excluded.body_blob`, [
+          orgId,
+          input.bundle.sha256,
+          input.bundle.byteSize,
+          input.bundle.contentType,
+          input.bundle.storageKind,
+          input.bundle.storageKey ?? null,
+          input.bundle.bytes ?? null,
+          now
+        ]);
+      }
+      const row = this.get(`INSERT INTO skills_registry (org_id, slug, display_name, description, category, tags_json, source, kind, version, skill_md,
+                                      bundle_sha256, bundle_byte_size, published_by_user_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (org_id, slug) DO UPDATE SET
+           display_name = excluded.display_name,
+           description = excluded.description,
+           category = excluded.category,
+           tags_json = excluded.tags_json,
+           source = excluded.source,
+           kind = excluded.kind,
+           version = excluded.version,
+           skill_md = excluded.skill_md,
+           -- COALESCE, not a straight assignment. A publish that carries no bundle is a
+           -- metadata update, not an instruction to discard the stored one: the plain
+           -- assignment nulled bundle_sha256 and then handed the old digest to orphan
+           -- collection, so re-publishing metadata over an existing skill deleted its
+           -- tarball and left every client with a 404.
+           bundle_sha256 = COALESCE(excluded.bundle_sha256, skills_registry.bundle_sha256),
+           bundle_byte_size = COALESCE(excluded.bundle_byte_size, skills_registry.bundle_byte_size),
+           published_by_user_id = excluded.published_by_user_id,
+           updated_at = excluded.updated_at
+         RETURNING *`, [
+        orgId,
+        input.slug,
+        input.displayName,
+        input.description,
+        input.category,
+        JSON.stringify(input.tags),
+        input.source,
+        input.kind,
+        input.version ?? null,
+        input.skillMd ?? null,
+        input.bundle?.sha256 ?? null,
+        input.bundle?.byteSize ?? null,
+        input.principal.userId,
+        now,
+        now
+      ]);
+      if (previousSha && input.bundle && previousSha !== input.bundle.sha256)
+        this.collectOrphanBundle(orgId, previousSha);
+      return rowToSkill(row);
+    })();
+  }
+  async listSkills(principal) {
+    return this.all("SELECT * FROM skills_registry WHERE org_id = ? ORDER BY slug ASC", [principal.orgId]).map(rowToSkill);
+  }
+  async getSkill(principal, slug) {
+    const row = this.get("SELECT * FROM skills_registry WHERE org_id = ? AND slug = ? LIMIT 1", [principal.orgId, slug]);
+    return row ? rowToSkill(row) : null;
+  }
+  async updateSkill(principal, slug, patch) {
+    const current = await this.getSkill(principal, slug);
+    if (!current)
+      return null;
+    const next = { ...current, ...patch };
+    const row = this.get(`UPDATE skills_registry
+       SET display_name = ?, description = ?, category = ?, tags_json = ?, kind = ?, version = ?, skill_md = ?, updated_at = ?
+       WHERE org_id = ? AND slug = ?
+       RETURNING *`, [
+      next.displayName,
+      next.description,
+      next.category,
+      JSON.stringify(next.tags),
+      next.kind,
+      next.version ?? null,
+      next.skillMd ?? null,
+      nowIso(),
+      principal.orgId,
+      slug
+    ]);
+    return row ? rowToSkill(row) : null;
+  }
+  async deleteSkill(principal, slug) {
+    return this.db.transaction(() => {
+      const existing = this.get("SELECT bundle_sha256 FROM skills_registry WHERE org_id = ? AND slug = ?", [principal.orgId, slug]);
+      if (!existing)
+        return false;
+      this.db.run("DELETE FROM skills_registry WHERE org_id = ? AND slug = ?", [principal.orgId, slug]);
+      if (typeof existing.bundle_sha256 === "string")
+        this.collectOrphanBundle(principal.orgId, existing.bundle_sha256);
+      return true;
+    })();
+  }
+  async getSkillBundle(principal, sha256) {
+    const row = this.get("SELECT * FROM skills_bundles WHERE org_id = ? AND sha256 = ? LIMIT 1", [principal.orgId, sha256]);
+    return row ? rowToSkillBundle(row) : null;
+  }
+  collectOrphanBundle(orgId, sha256) {
+    const referenced = this.get("SELECT 1 AS present FROM skills_registry WHERE org_id = ? AND bundle_sha256 = ? LIMIT 1", [orgId, sha256]);
+    if (referenced)
+      return;
+    this.db.run("DELETE FROM skills_bundles WHERE org_id = ? AND sha256 = ?", [orgId, sha256]);
+  }
+  get(sql, params) {
+    return this.db.query(sql).get(...params) ?? null;
+  }
+  all(sql, params) {
+    return this.db.query(sql).all(...params);
+  }
+  rollbackQuietly() {
+    try {
+      this.db.exec("ROLLBACK");
+    } catch {}
+  }
+}
+function applySqliteMigrations(db, migrationsDir = resolveMigrationsDir("sqlite")) {
+  db.exec(`CREATE TABLE IF NOT EXISTS schema_migrations (
+       version text PRIMARY KEY,
+       applied_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+     )`);
+  const files = readdirSync2(migrationsDir).filter((name) => name.endsWith(".sql")).sort();
+  if (files.length === 0) {
+    throw new Error(`no .sql migrations found in ${migrationsDir}`);
+  }
+  const appliedNow = [];
+  for (const file of files) {
+    const version2 = file.replace(/\.sql$/, "");
+    const text = readFileSync3(join5(migrationsDir, file), "utf8");
+    const apply = db.transaction(() => {
+      const already = db.query("SELECT 1 AS present FROM schema_migrations WHERE version = ? LIMIT 1").get(version2);
+      if (already)
+        return false;
+      db.exec(text);
+      db.run("INSERT INTO schema_migrations (version) VALUES (?)", [version2]);
+      return true;
+    });
+    if (apply.immediate())
+      appliedNow.push(version2);
+  }
+  return appliedNow;
+}
+function enableWalMode(db, attempts = 50, pauseMs = 10) {
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    if (journalMode(db) === "wal")
+      return true;
+    try {
+      if (String(db.query("PRAGMA journal_mode = WAL").get()?.journal_mode).toLowerCase() === "wal") {
+        return true;
+      }
+    } catch {}
+    Bun.sleepSync(pauseMs);
+  }
+  return false;
+}
+function journalMode(db) {
+  try {
+    return String(db.query("PRAGMA journal_mode").get()?.journal_mode ?? "").toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function openDatabase(path) {
+  try {
+    return new Database(path, { create: true, readwrite: true });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`cannot open the skills database at ${path}: ${reason}. ` + "Check that the directory exists and is writable. Set HASNA_SKILLS_DATABASE_URL to choose a " + "different path or a postgres:// URL, or HASNA_SKILLS_DIR to relocate the whole data directory.", { cause: error });
+  }
+}
+function parseScopes(value) {
+  if (Array.isArray(value))
+    return value.map(String);
+  if (typeof value !== "string")
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.map(String) : [];
+  } catch {
+    return [];
+  }
+}
+
+// src/server/store.ts
+function resolvePoolMax(env = process.env) {
+  const parsed = Number.parseInt(env.HASNA_SKILLS_DATABASE_POOL_MAX || env.SKILLS_DATABASE_POOL_MAX || "", 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 4;
+}
+var LOG_SEQUENCE_ATTEMPTS = 12;
+function createArtifactId() {
+  return artifactId();
+}
+async function createStore(options = {}) {
+  const target = resolveDatabaseTarget(options.databaseUrl);
+  const store = instantiateStore(target, options.sqlite);
+  await store.verifyConnectivity?.();
+  if (options.bootstrapApiKey && store.ensureBootstrapApiKey) {
+    await store.ensureBootstrapApiKey(options.bootstrapApiKey);
+  }
+  return store;
+}
+function instantiateStore(target, sqliteOptions) {
+  switch (target.kind) {
+    case "postgres":
+      return new PostgresSkillsStore(target.url);
+    case "sqlite":
+      return new SqliteSkillsStore(target.path, sqliteOptions);
+    case "memory":
+      return new MemorySkillsStore;
+  }
+}
+
+class MemorySkillsStore {
+  backend = { kind: "memory", durable: false, label: "memory (non-durable)" };
+  apiKeys = new Map;
+  runs = new Map;
+  logs = new Map;
+  artifacts = new Map;
+  idempotency = new Map;
+  skills = new Map;
+  bundles = new Map;
+  constructor(apiKeys = []) {
+    for (const key of apiKeys)
+      this.addApiKey(key.token, key.principal);
+  }
+  addApiKey(token, principal) {
+    const resolved = publicPrincipal(principal);
+    this.apiKeys.set(hashApiKey(token), resolved);
+    return resolved;
+  }
+  async ensureBootstrapApiKey(token, principal) {
+    this.addApiKey(token, principal);
+  }
+  async authenticateApiKeyHash(hash) {
+    return this.apiKeys.get(hash) ?? null;
+  }
+  async createRun(input) {
+    const idemKey = input.idempotencyKey?.trim();
     const idemMapKey = idemKey ? `${input.principal.orgId}:${idemKey}` : undefined;
     if (idemMapKey) {
       const existing = this.idempotency.get(idemMapKey);
@@ -30470,7 +31428,7 @@ class MemorySkillsStore {
       input: input.input,
       args: input.args,
       ...idemKey ? { idempotencyKey: idemKey } : {},
-      correlationId: randomUUID(),
+      correlationId: randomUUID3(),
       costCents: 0,
       createdAt: now
     };
@@ -30482,17 +31440,17 @@ class MemorySkillsStore {
     return run;
   }
   async listRuns(principal, limit) {
-    return Array.from(this.runs.values()).filter((run) => run.orgId === principal.orgId).sort((a3, b3) => b3.createdAt.localeCompare(a3.createdAt)).slice(0, limit);
+    return Array.from(this.runs.values()).filter((run) => run.orgId === principal.orgId).sort((a3, b3) => b3.createdAt.localeCompare(a3.createdAt)).slice(0, normalizeLimit(limit));
   }
   async getRun(principal, runId2) {
     const run = this.runs.get(runId2);
     return run && run.orgId === principal.orgId ? run : null;
   }
-  async claimNextRun(input) {
+  async claimNextRun(_input) {
     const run = Array.from(this.runs.values()).filter((candidate) => candidate.status === "queued" || candidate.status === "retrying").sort((a3, b3) => a3.createdAt.localeCompare(b3.createdAt))[0];
     if (!run)
       return null;
-    return this.patchRun(run.id, { status: "running", startedAt: nowIso() });
+    return this.patchRun(run.id, { status: "running", startedAt: run.startedAt ?? nowIso() });
   }
   async updateRun(runId2, patch) {
     return this.patchRun(runId2, patch);
@@ -30523,6 +31481,74 @@ class MemorySkillsStore {
     const artifacts = await this.listArtifacts(principal, runId2);
     return artifacts.find((artifact) => artifact.id === id) ?? null;
   }
+  async publishSkill(input) {
+    const key = skillKey(input.principal.orgId, input.slug);
+    const now = nowIso();
+    const previous = this.skills.get(key);
+    if (input.bundle) {
+      const bundleMapKey = skillKey(input.principal.orgId, input.bundle.sha256);
+      this.bundles.set(bundleMapKey, {
+        ...this.bundles.get(bundleMapKey),
+        ...input.bundle,
+        orgId: input.principal.orgId,
+        createdAt: this.bundles.get(bundleMapKey)?.createdAt ?? now
+      });
+    }
+    const record = {
+      orgId: input.principal.orgId,
+      slug: input.slug,
+      displayName: input.displayName,
+      description: input.description,
+      category: input.category,
+      tags: [...input.tags],
+      source: input.source,
+      kind: input.kind,
+      ...input.version ? { version: input.version } : {},
+      ...input.skillMd ? { skillMd: input.skillMd } : {},
+      ...input.bundle ? { bundleSha256: input.bundle.sha256, bundleByteSize: input.bundle.byteSize } : previous?.bundleSha256 ? { bundleSha256: previous.bundleSha256, ...previous.bundleByteSize === undefined ? {} : { bundleByteSize: previous.bundleByteSize } } : {},
+      publishedByUserId: input.principal.userId,
+      createdAt: previous?.createdAt ?? now,
+      updatedAt: now
+    };
+    this.skills.set(key, record);
+    if (previous?.bundleSha256 && input.bundle && previous.bundleSha256 !== input.bundle.sha256) {
+      this.collectOrphanBundle(input.principal.orgId, previous.bundleSha256);
+    }
+    return record;
+  }
+  async listSkills(principal) {
+    return Array.from(this.skills.values()).filter((skill) => skill.orgId === principal.orgId).sort((a3, b3) => a3.slug.localeCompare(b3.slug));
+  }
+  async getSkill(principal, slug) {
+    const skill = this.skills.get(skillKey(principal.orgId, slug));
+    return skill && skill.orgId === principal.orgId ? skill : null;
+  }
+  async updateSkill(principal, slug, patch) {
+    const current = await this.getSkill(principal, slug);
+    if (!current)
+      return null;
+    const next = { ...current, ...patch, updatedAt: nowIso() };
+    this.skills.set(skillKey(principal.orgId, slug), next);
+    return next;
+  }
+  async deleteSkill(principal, slug) {
+    const current = await this.getSkill(principal, slug);
+    if (!current)
+      return false;
+    this.skills.delete(skillKey(principal.orgId, slug));
+    if (current.bundleSha256)
+      this.collectOrphanBundle(principal.orgId, current.bundleSha256);
+    return true;
+  }
+  async getSkillBundle(principal, sha256) {
+    const bundle = this.bundles.get(skillKey(principal.orgId, sha256));
+    return bundle && bundle.orgId === principal.orgId ? bundle : null;
+  }
+  collectOrphanBundle(orgId, sha256) {
+    const referenced = Array.from(this.skills.values()).some((skill) => skill.orgId === orgId && skill.bundleSha256 === sha256);
+    if (!referenced)
+      this.bundles.delete(skillKey(orgId, sha256));
+  }
   patchRun(runId2, patch) {
     const run = this.runs.get(runId2);
     if (!run)
@@ -30532,13 +31558,32 @@ class MemorySkillsStore {
     return next;
   }
 }
+function skillKey(orgId, slug) {
+  return `${orgId.length}:${orgId}:${slug}`;
+}
 
 class PostgresSkillsStore {
+  backend = { kind: "postgres", durable: true, label: "postgres" };
   sql;
   constructor(databaseUrl) {
     const bunWithSql = Bun;
     this.sql = new bunWithSql.SQL(databaseUrl, { max: resolvePoolMax() });
   }
+  async verifyConnectivity() {
+    try {
+      await this.sql`SELECT 1`;
+    } catch (error) {
+      throw new Error("cannot reach the configured Postgres database. The server will not start with an unreachable " + "database rather than fall back to another backend and silently split your data across two stores. " + `Check HASNA_SKILLS_DATABASE_URL and that the instance is accepting connections. Driver reported: ${connectionFailureSummary(error)}`);
+    }
+    try {
+      await this.sql`SELECT 1 FROM api_keys LIMIT 0`;
+    } catch (error) {
+      throw new Error("the configured Postgres database is reachable but has no skills schema. Run `skills-migrate` against it " + "before starting the server - unlike SQLite, Postgres is not migrated automatically, so that several " + `replicas cannot race to migrate a shared database. Driver reported: ${connectionFailureSummary(error)}`);
+    }
+  }
+  async close() {
+    await this.sql.close?.();
+  }
   async ensureBootstrapApiKey(token, principal) {
     const resolved = publicPrincipal(principal);
     await this.sql`
@@ -30601,7 +31646,7 @@ class PostgresSkillsStore {
     const id = runId();
     const rows = await this.sql`
       INSERT INTO skills_runs (id, org_id, user_id, skill_slug, requested_slug, status, input_json, args_json, idempotency_key, correlation_id)
-      VALUES (${id}, ${input.principal.orgId}, ${input.principal.userId}, ${input.slug}, ${input.slug}, ${"queued"}, ${JSON.stringify(input.input)}::jsonb, ${JSON.stringify(input.args)}::jsonb, ${input.idempotencyKey ?? null}, ${randomUUID()})
+      VALUES (${id}, ${input.principal.orgId}, ${input.principal.userId}, ${input.slug}, ${input.slug}, ${"queued"}, ${JSON.stringify(input.input)}::jsonb, ${JSON.stringify(input.args)}::jsonb, ${input.idempotencyKey ?? null}, ${randomUUID3()})
       RETURNING *
     `;
     return rowToRun(rows[0]);
@@ -30609,7 +31654,7 @@ class PostgresSkillsStore {
   async listRuns(principal, limit) {
     const rows = await this.sql`
       SELECT * FROM skills_runs WHERE org_id = ${principal.orgId}
-      ORDER BY created_at DESC LIMIT ${limit}
+      ORDER BY created_at DESC LIMIT ${normalizeLimit(limit)}
     `;
     return rows.map(rowToRun);
   }
@@ -30654,14 +31699,28 @@ class PostgresSkillsStore {
     return rows[0] ? rowToRun(rows[0]) : null;
   }
   async appendLog(runId2, orgId, level, message) {
-    const seqRows = await this.sql`SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM skills_run_logs WHERE run_id = ${runId2}`;
-    const sequence = Number(seqRows[0]?.next_sequence ?? 1);
-    const rows = await this.sql`
-      INSERT INTO skills_run_logs (run_id, org_id, sequence, level, message)
-      VALUES (${runId2}, ${orgId}, ${sequence}, ${level}, ${message})
-      RETURNING *
-    `;
-    return rowToLog(rows[0]);
+    let lastError;
+    for (let attempt = 0;attempt < LOG_SEQUENCE_ATTEMPTS; attempt += 1) {
+      try {
+        const rows = await this.sql`
+          INSERT INTO skills_run_logs (run_id, org_id, sequence, level, message)
+          VALUES (
+            ${runId2},
+            ${orgId},
+            (SELECT COALESCE(MAX(sequence), 0) + 1 FROM skills_run_logs WHERE run_id = ${runId2}),
+            ${level},
+            ${message}
+          )
+          RETURNING *
+        `;
+        return rowToLog(rows[0]);
+      } catch (error) {
+        if (!isUniqueViolation(error))
+          throw error;
+        lastError = error;
+      }
+    }
+    throw lastError;
   }
   async listLogs(principal, runId2) {
     const rows = await this.sql`
@@ -30698,80 +31757,121 @@ class PostgresSkillsStore {
     `;
     return rows[0] ? rowToArtifact(rows[0]) : null;
   }
-}
-function rowToRun(row) {
-  return {
-    id: String(row.id),
-    orgId: String(row.org_id),
-    userId: String(row.user_id),
-    skill: String(row.skill_slug),
-    requestedSlug: String(row.requested_slug),
-    status: String(row.status),
-    input: parseJsonObject(row.input_json),
-    args: parseJsonArray(row.args_json),
-    ...typeof row.idempotency_key === "string" ? { idempotencyKey: row.idempotency_key } : {},
-    correlationId: String(row.correlation_id),
-    costCents: Number(row.cost_cents ?? 0),
-    ...typeof row.output_type === "string" ? { outputType: row.output_type } : {},
-    ...typeof row.output_preview === "string" ? { outputPreview: row.output_preview } : {},
-    ...typeof row.error_code === "string" ? { errorCode: row.error_code } : {},
-    ...typeof row.error_message === "string" ? { errorMessage: row.error_message } : {},
-    createdAt: dateString(row.created_at),
-    ...row.started_at ? { startedAt: dateString(row.started_at) } : {},
-    ...row.completed_at ? { completedAt: dateString(row.completed_at) } : {}
-  };
-}
-function rowToLog(row) {
-  return {
-    runId: String(row.run_id),
-    sequence: Number(row.sequence),
-    level: String(row.level),
-    message: String(row.message),
-    createdAt: dateString(row.created_at)
-  };
-}
-function rowToArtifact(row) {
-  return {
-    id: String(row.id),
-    runId: String(row.run_id),
-    orgId: String(row.org_id),
-    fileName: String(row.file_name),
-    relativePath: String(row.relative_path),
-    contentType: String(row.content_type),
-    byteSize: Number(row.byte_size),
-    sha256: String(row.sha256),
-    storageKind: String(row.storage_kind),
-    ...typeof row.storage_key === "string" ? { storageKey: row.storage_key } : {},
-    ...typeof row.body_text === "string" ? { bodyText: row.body_text } : {},
-    createdAt: dateString(row.created_at)
-  };
-}
-function parseJsonObject(value) {
-  if (value && typeof value === "object" && !Array.isArray(value))
-    return value;
-  if (typeof value === "string") {
-    try {
-      const parsed = JSON.parse(value);
-      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-    } catch {}
+  async publishSkill(input) {
+    const orgId = input.principal.orgId;
+    return await this.sql.begin(async (tx) => {
+      const previousRows = await tx`SELECT bundle_sha256 FROM skills_registry WHERE org_id = ${orgId} AND slug = ${input.slug} LIMIT 1`;
+      const previousSha = typeof previousRows[0]?.bundle_sha256 === "string" ? String(previousRows[0].bundle_sha256) : null;
+      if (input.bundle) {
+        await tx`
+          INSERT INTO skills_bundles (org_id, sha256, byte_size, content_type, storage_kind, storage_key, body_blob)
+          VALUES (${orgId}, ${input.bundle.sha256}, ${input.bundle.byteSize}, ${input.bundle.contentType}, ${input.bundle.storageKind}, ${input.bundle.storageKey ?? null}, ${input.bundle.bytes ?? null})
+          ON CONFLICT (org_id, sha256) DO UPDATE SET
+            byte_size = EXCLUDED.byte_size,
+            content_type = EXCLUDED.content_type,
+            storage_kind = EXCLUDED.storage_kind,
+            storage_key = EXCLUDED.storage_key,
+            body_blob = EXCLUDED.body_blob
+        `;
+      }
+      const rows = await tx`
+        INSERT INTO skills_registry (org_id, slug, display_name, description, category, tags_json, source, kind, version, skill_md,
+                                     bundle_sha256, bundle_byte_size, published_by_user_id, updated_at)
+        VALUES (${orgId}, ${input.slug}, ${input.displayName}, ${input.description}, ${input.category}, ${JSON.stringify(input.tags)}::jsonb,
+                ${input.source}, ${input.kind}, ${input.version ?? null}, ${input.skillMd ?? null},
+                ${input.bundle?.sha256 ?? null}, ${input.bundle?.byteSize ?? null}, ${input.principal.userId}, now())
+        ON CONFLICT (org_id, slug) DO UPDATE SET
+          display_name = EXCLUDED.display_name,
+          description = EXCLUDED.description,
+          category = EXCLUDED.category,
+          tags_json = EXCLUDED.tags_json,
+          source = EXCLUDED.source,
+          kind = EXCLUDED.kind,
+          version = EXCLUDED.version,
+          skill_md = EXCLUDED.skill_md,
+          -- COALESCE: see the SQLite twin. A bundle-less publish is a metadata update,
+          -- not an instruction to discard the stored tarball.
+          bundle_sha256 = COALESCE(EXCLUDED.bundle_sha256, skills_registry.bundle_sha256),
+          bundle_byte_size = COALESCE(EXCLUDED.bundle_byte_size, skills_registry.bundle_byte_size),
+          published_by_user_id = EXCLUDED.published_by_user_id,
+          updated_at = EXCLUDED.updated_at
+        RETURNING *
+      `;
+      if (previousSha && input.bundle && previousSha !== input.bundle.sha256) {
+        await tx`
+          DELETE FROM skills_bundles
+          WHERE org_id = ${orgId} AND sha256 = ${previousSha}
+            AND NOT EXISTS (SELECT 1 FROM skills_registry WHERE org_id = ${orgId} AND bundle_sha256 = ${previousSha})
+        `;
+      }
+      return rowToSkill(rows[0]);
+    });
   }
-  return {};
-}
-function parseJsonArray(value) {
-  const parsed = typeof value === "string" ? safeParse(value) : value;
-  return Array.isArray(parsed) ? parsed.map(String) : [];
-}
-function safeParse(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return;
+  async listSkills(principal) {
+    const rows = await this.sql`SELECT * FROM skills_registry WHERE org_id = ${principal.orgId} ORDER BY slug ASC`;
+    return rows.map(rowToSkill);
+  }
+  async getSkill(principal, slug) {
+    const rows = await this.sql`SELECT * FROM skills_registry WHERE org_id = ${principal.orgId} AND slug = ${slug} LIMIT 1`;
+    return rows[0] ? rowToSkill(rows[0]) : null;
+  }
+  async updateSkill(principal, slug, patch) {
+    const current = await this.getSkill(principal, slug);
+    if (!current)
+      return null;
+    const next = { ...current, ...patch };
+    const rows = await this.sql`
+      UPDATE skills_registry
+      SET display_name = ${next.displayName}, description = ${next.description}, category = ${next.category},
+          tags_json = ${JSON.stringify(next.tags)}::jsonb, kind = ${next.kind}, version = ${next.version ?? null},
+          skill_md = ${next.skillMd ?? null}, updated_at = now()
+      WHERE org_id = ${principal.orgId} AND slug = ${slug}
+      RETURNING *
+    `;
+    return rows[0] ? rowToSkill(rows[0]) : null;
+  }
+  async deleteSkill(principal, slug) {
+    return await this.sql.begin(async (tx) => {
+      const rows = await tx`
+        DELETE FROM skills_registry WHERE org_id = ${principal.orgId} AND slug = ${slug}
+        RETURNING bundle_sha256
+      `;
+      if (!rows[0])
+        return false;
+      const sha = rows[0].bundle_sha256;
+      if (typeof sha === "string") {
+        await tx`
+          DELETE FROM skills_bundles
+          WHERE org_id = ${principal.orgId} AND sha256 = ${sha}
+            AND NOT EXISTS (SELECT 1 FROM skills_registry WHERE org_id = ${principal.orgId} AND bundle_sha256 = ${sha})
+        `;
+      }
+      return true;
+    });
+  }
+  async getSkillBundle(principal, sha256) {
+    const rows = await this.sql`SELECT * FROM skills_bundles WHERE org_id = ${principal.orgId} AND sha256 = ${sha256} LIMIT 1`;
+    return rows[0] ? rowToSkillBundle(rows[0]) : null;
+  }
+  async collectOrphanBundle(orgId, sha256) {
+    await this.sql`
+      DELETE FROM skills_bundles
+      WHERE org_id = ${orgId} AND sha256 = ${sha256}
+        AND NOT EXISTS (SELECT 1 FROM skills_registry WHERE org_id = ${orgId} AND bundle_sha256 = ${sha256})
+    `;
   }
 }
-function dateString(value) {
-  if (value instanceof Date)
-    return value.toISOString();
-  return String(value);
+function isUniqueViolation(error) {
+  const code = error?.code;
+  if (code === "23505" || code === 23505)
+    return true;
+  const message = error instanceof Error ? error.message : String(error);
+  return /duplicate key value violates unique constraint/i.test(message);
+}
+function connectionFailureSummary(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/[a-z][a-z0-9+.-]*:\/\/\S*/gi, "<redacted-url>").split(`
+`)[0].slice(0, 200);
 }
 
 // src/server/redaction.ts
@@ -30799,16 +31899,16 @@ var DETERMINISTIC_TEXT_HANDLERS = new Set([
 ]);
 async function executeRun(store, run, storage = new ArtifactStorage) {
   try {
-    await store.appendLog(run.id, run.orgId, "info", redactForClient(`starting self-hosted run ${run.skill}`));
+    await store.appendLog(run.id, run.orgId, "info", redactForClient(`starting run ${run.skill}`));
     if (!DETERMINISTIC_TEXT_HANDLERS.has(run.skill)) {
-      await store.appendLog(run.id, run.orgId, "warn", `${run.skill} has no self-hosted provider-free handler yet`);
-      return await failRun(store, run, "HANDLER_UNAVAILABLE", "This self-hosted deployment has no safe provider-free handler for that skill yet.");
+      await store.appendLog(run.id, run.orgId, "warn", `${run.skill} has no provider-free handler yet`);
+      return await failRun(store, run, "HANDLER_UNAVAILABLE", "This deployment has no safe provider-free handler for that skill yet.");
     }
     const text = extractText(run);
     if (!text.trim()) {
       return await failRun(store, run, "INVALID_INPUT", "Provide transcript text with input.transcript, input.text, --text, --source, or positional text.");
     }
-    const title = extractOption(run.args, "--title") || stringInput(run.input, "title") || "Self-hosted Skills run";
+    const title = extractOption(run.args, "--title") || stringInput(run.input, "title") || "Skills run";
     const summary = summarize(text);
     const artifacts = [
       textArtifact(run, "transcript.md", `# ${title}
@@ -30822,7 +31922,7 @@ ${summary}
       textArtifact(run, "show-notes.md", `# Show Notes
 
 - ${summary}
-- Generated by open-skills self-hosted deterministic worker.
+- Generated by the open-skills deterministic worker.
 `),
       textArtifact(run, "clips.csv", `start,end,title,summary
 00:00,00:30,"Opening","${csv(summary)}"
@@ -30907,8 +32007,831 @@ function csv(value) {
   return value.replace(/"/g, '""');
 }
 
+// src/lib/registry-data/development-tools.ts
+var DEVELOPMENT_TOOLS_SKILLS = [
+  {
+    name: "repo-onboarding-report",
+    displayName: "Repo Onboarding Report",
+    description: "Generate repository onboarding packages with architecture maps, setup guides, risk registers, and first-week plans",
+    category: "Development Tools",
+    kind: "instruction",
+    tags: ["repository", "onboarding", "architecture", "developer-tools"]
+  },
+  {
+    name: "security-audit-report",
+    displayName: "Security Audit Report",
+    description: "Generate application security hardening reports covering auth, secrets, headers, webhooks, RLS, permissions, dependencies, and prioritized fixes",
+    category: "Development Tools",
+    kind: "instruction",
+    tags: ["security", "audit", "hardening", "rls", "webhooks"]
+  },
+  {
+    name: "performance-audit-report",
+    displayName: "Performance Audit Report",
+    description: "Generate performance audit reports with metrics, findings, budgets, remediation plans, and manifest artifacts",
+    category: "Development Tools",
+    kind: "instruction",
+    tags: ["performance", "audit", "latency", "budget", "web"]
+  },
+  {
+    name: "migration-plan-pack",
+    displayName: "Migration Plan Pack",
+    description: "Generate migration plans for frameworks, libraries, databases, infrastructure, and architecture upgrades with risk matrix, checklist, rollout, and test strategy artifacts",
+    category: "Development Tools",
+    kind: "instruction",
+    tags: ["migration", "upgrade", "planning", "frameworks", "databases"]
+  },
+  {
+    name: "test-suite-generator",
+    displayName: "Test Suite Generator",
+    description: "Generate runnable API, unit, and browser test suite packages with coverage notes",
+    category: "Development Tools",
+    kind: "instruction",
+    tags: ["testing", "qa", "api-tests", "browser-tests", "coverage"]
+  },
+  {
+    name: "api-test-suite",
+    displayName: "API Test Suite",
+    description: "Generate and run API test suites with comprehensive endpoint coverage",
+    category: "Development Tools",
+    tags: ["api", "testing", "automation", "qa"]
+  },
+  {
+    name: "api-docs-portal",
+    displayName: "API Docs Portal",
+    description: "Generate static API documentation portals from OpenAPI specs, route lists, and endpoint examples",
+    category: "Development Tools",
+    tags: ["api", "documentation", "openapi", "portal"]
+  },
+  {
+    name: "codefix",
+    displayName: "Code Fix",
+    description: "Code quality CLI for auto-linting, formatting, fixing, and style enforcement",
+    category: "Development Tools",
+    tags: ["code", "linting", "formatting", "quality"]
+  },
+  {
+    name: "commitpush",
+    displayName: "Commit Push",
+    description: "Create logical commits from repo changes and push directly to the main branch",
+    category: "Development Tools",
+    tags: ["git", "commit", "push", "automation"]
+  },
+  {
+    name: "commitpushpr",
+    displayName: "Commit Push PR",
+    description: "Create logical commits, push a feature branch, and open a GitHub pull request",
+    category: "Development Tools",
+    dependencies: ["commitpush"],
+    tags: ["git", "commit", "pull-request", "github", "automation"]
+  },
+  {
+    name: "database-explorer",
+    displayName: "Database Explorer",
+    description: "Explore and query databases with an interactive interface",
+    category: "Development Tools",
+    tags: ["database", "explorer", "sql", "query"]
+  },
+  {
+    name: "diff-viewer",
+    displayName: "Diff Viewer",
+    description: "View and analyze file differences with visual diff representation",
+    category: "Development Tools",
+    tags: ["diff", "comparison", "files", "code-review"]
+  },
+  {
+    name: "generate-api-client",
+    displayName: "Generate API Client",
+    description: "Generate API client libraries from OpenAPI specs and documentation",
+    category: "Development Tools",
+    tags: ["api", "client", "code-generation", "openapi"]
+  },
+  {
+    name: "generate-dockerfile",
+    displayName: "Generate Dockerfile",
+    description: "Generate optimized Dockerfiles for containerized applications",
+    category: "Development Tools",
+    tags: ["docker", "dockerfile", "containers", "devops"]
+  },
+  {
+    name: "generate-env",
+    displayName: "Generate Env",
+    description: "Generate environment variable files from templates and configurations",
+    category: "Development Tools",
+    tags: ["env", "environment", "configuration", "dotenv"]
+  },
+  {
+    name: "generate-sitemap",
+    displayName: "Generate Sitemap",
+    description: "Generate XML sitemaps for websites and web applications",
+    category: "Development Tools",
+    tags: ["sitemap", "seo", "xml", "web"]
+  },
+  {
+    name: "hook",
+    displayName: "Hook",
+    description: "Claude Code hook creation skill - generates standardized hook scaffolds",
+    category: "Development Tools",
+    tags: ["hooks", "scaffold", "claude-code", "automation"]
+  },
+  {
+    name: "http-server",
+    displayName: "HTTP Server",
+    description: "Spin up local HTTP servers for development and testing",
+    category: "Development Tools",
+    tags: ["http", "server", "development", "local"]
+  },
+  {
+    name: "lorem-generator",
+    displayName: "Lorem Generator",
+    description: "Generate placeholder text in various styles and lengths",
+    category: "Development Tools",
+    tags: ["lorem", "placeholder", "text", "mockup"]
+  },
+  {
+    name: "managemcp",
+    displayName: "Manage MCP",
+    description: "Manage MCP servers with install, configure, and lifecycle operations",
+    category: "Development Tools",
+    tags: ["mcp", "management", "servers", "configuration"]
+  },
+  {
+    name: "markdown-validator",
+    displayName: "Markdown Validator",
+    description: "Validate markdown files for syntax, links, and formatting issues",
+    category: "Development Tools",
+    tags: ["markdown", "validation", "linting", "formatting"]
+  },
+  {
+    name: "monitor",
+    displayName: "Monitor",
+    description: "Operate the open-monitor MCP for machine health, processes, cron jobs, and cleanup workflows",
+    category: "Development Tools",
+    tags: ["monitoring", "mcp", "processes", "operations"]
+  },
+  {
+    name: "regex-tester",
+    displayName: "Regex Tester",
+    description: "Test and validate regular expressions with sample inputs",
+    category: "Development Tools",
+    tags: ["regex", "testing", "validation", "patterns"]
+  },
+  {
+    name: "scancommitpr",
+    displayName: "Scan Commit PR",
+    description: "Scan repo changes, group into logical commits, push, and optionally create a PR",
+    category: "Development Tools",
+    dependencies: ["scancommitpush"],
+    tags: ["git", "commit", "push", "pull-request", "automation"]
+  },
+  {
+    name: "scancommitpush",
+    displayName: "Scan Commit Push",
+    description: "Scan repo changes, group into logical commits with conventional messages, and push to GitHub",
+    category: "Development Tools",
+    tags: ["git", "commit", "push", "automation"]
+  },
+  {
+    name: "security-audit",
+    displayName: "Security Audit",
+    description: "Perform security audits on codebases and infrastructure configurations",
+    category: "Development Tools",
+    tags: ["security", "audit", "vulnerabilities", "scanning"]
+  },
+  {
+    name: "tmux-session",
+    displayName: "Tmux Session",
+    description: "Create and manage grouped tmux sessions with workspace-aware naming and window layout guidance",
+    category: "Development Tools",
+    tags: ["tmux", "terminal", "sessions", "workspace"]
+  },
+  {
+    name: "validate-config",
+    displayName: "Validate Config",
+    description: "Validate configuration files for syntax and schema compliance",
+    category: "Development Tools",
+    tags: ["config", "validation", "schema", "linting"]
+  }
+];
+
+// src/lib/registry-data/business-marketing.ts
+var BUSINESS_MARKETING_SKILLS = [
+  {
+    name: "customer-feedback-report",
+    displayName: "Customer Feedback Report",
+    description: "Generate customer feedback reports with clusters, sentiment, root causes, roadmap recommendations, evidence, and PDF/Markdown artifacts",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["feedback", "customer", "sentiment", "roadmap", "report"]
+  },
+  {
+    name: "pitch-deck",
+    displayName: "Pitch Deck",
+    description: "Generate investor and sales deck packages with slides, speaker notes, design direction, PDF, and PPTX artifacts",
+    category: "Business & Marketing",
+    kind: "instruction",
+    dependencies: ["market-research-report"],
+    tags: ["deck", "presentation", "investor", "sales", "pptx"]
+  },
+  {
+    name: "proposal-pack",
+    displayName: "Proposal Pack",
+    description: "Generate client proposal packages with proposal, statement of work, pricing, timeline, assumptions, cover email, and PDF/Markdown artifacts",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["proposal", "sow", "sales", "pricing", "timeline"]
+  },
+  {
+    name: "seo-content-pack",
+    displayName: "SEO Content Pack",
+    description: "Generate SEO content packages with topic clusters, articles, metadata, internal links, FAQs, and publishing cadence",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["seo", "content", "articles", "metadata"]
+  },
+  {
+    name: "landing-page-pack",
+    displayName: "Landing Page Pack",
+    description: "Generate landing page packages with conversion copy, wireframes, CTA maps, experiments, preview HTML, and implementation notes",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["landing-page", "sales", "copywriting", "conversion"]
+  },
+  {
+    name: "ad-creative-pack",
+    displayName: "Ad Creative Pack",
+    description: "Generate paid ad packages with platform copy, creative concepts, image prompts, audience angles, and test matrices",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["ads", "creative", "marketing", "copywriting"]
+  },
+  {
+    name: "email-sequence",
+    displayName: "Email Sequence",
+    description: "Generate email campaign packages with subject lines, preview text, body copy, segmentation notes, CTA variants, HTML emails, and send plans",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["email", "marketing", "campaign", "copywriting"]
+  },
+  {
+    name: "social-content-calendar",
+    displayName: "Social Content Calendar",
+    description: "Generate social content calendars with daily posts, channel strategy, asset briefs, hooks, publishing schedules, and repurposing maps",
+    category: "Business & Marketing",
+    kind: "instruction",
+    tags: ["social", "content", "calendar", "marketing"]
+  },
+  {
+    name: "one-page-website",
+    displayName: "One Page Website",
+    description: "Generate static one-page website bundles with HTML, CSS, JavaScript, copy, section maps, deploy notes, and manifest",
+    category: "Business & Marketing",
+    tags: ["website", "landing-page", "static-site", "html"]
+  }
+];
+
+// src/lib/registry-data/productivity-organization.ts
+var PRODUCTIVITY_ORGANIZATION_SKILLS = [
+  {
+    name: "meeting-pack",
+    displayName: "Meeting Pack",
+    description: "Generate meeting artifact packages with summaries, decisions, action items, follow-up email, timeline, project export, and manifest",
+    category: "Productivity & Organization",
+    kind: "instruction",
+    tags: ["meeting", "summary", "action-items", "decisions"]
+  },
+  {
+    name: "file-organizer",
+    displayName: "File Organizer",
+    description: "Organize files into structured directories based on type, date, or content",
+    category: "Productivity & Organization",
+    tags: ["files", "organization", "sorting", "cleanup"]
+  },
+  {
+    name: "folder-tree",
+    displayName: "Folder Tree",
+    description: "Generate and display folder tree structures for documentation",
+    category: "Productivity & Organization",
+    tags: ["folder", "tree", "structure", "visualization"]
+  },
+  {
+    name: "form-filler",
+    displayName: "Form Filler",
+    description: "Automatically fill out web forms and document templates",
+    category: "Productivity & Organization",
+    tags: ["forms", "automation", "filling", "data-entry"]
+  },
+  {
+    name: "merge-pdfs",
+    displayName: "Merge PDFs",
+    description: "Merge multiple PDF files into a single document",
+    category: "Productivity & Organization",
+    tags: ["pdf", "merge", "documents", "combining"]
+  },
+  {
+    name: "split-pdf",
+    displayName: "Split PDF",
+    description: "Split PDF documents into separate pages or sections",
+    category: "Productivity & Organization",
+    tags: ["pdf", "split", "documents", "pages"]
+  }
+];
+
+// src/lib/registry-data/project-management.ts
+var PROJECT_MANAGEMENT_SKILLS = [
+  {
+    name: "businessactivity",
+    displayName: "Business Activity",
+    description: "Business activity, workflow, and ownership management service",
+    category: "Project Management",
+    tags: ["business", "workflow", "activities", "management"]
+  },
+  {
+    name: "implementation",
+    displayName: "Implementation",
+    description: "Create .implementation scaffold for project development tracking",
+    category: "Project Management",
+    tags: ["implementation", "tracking", "scaffold", "project"]
+  },
+  {
+    name: "implementation-plan",
+    displayName: "Implementation Plan",
+    description: "Generate detailed implementation plans with phases and milestones",
+    category: "Project Management",
+    tags: ["implementation", "planning", "milestones", "phases"]
+  },
+  {
+    name: "implementation-todo",
+    displayName: "Implementation Todo",
+    description: "Manage implementation task lists and todo items",
+    category: "Project Management",
+    tags: ["implementation", "todo", "tasks", "tracking"]
+  },
+  {
+    name: "todos-plan",
+    displayName: "Todos Plan",
+    description: "Author, sync, route, and verify Todos plans using Todos CLI plan IDs as source of truth",
+    category: "Project Management",
+    tags: ["todos", "plans", "tasks", "verification", "workflow"]
+  }
+];
+
+// src/lib/registry-data/content-generation.ts
+var CONTENT_GENERATION_SKILLS = [
+  {
+    name: "pdf-generate",
+    displayName: "PDF Generate",
+    description: "Generate PDF documents with rich formatting and layouts",
+    category: "Content Generation",
+    tags: ["pdf", "document", "generation", "formatting"]
+  },
+  {
+    name: "slide-deck-generator",
+    displayName: "Slide Deck Generator",
+    description: "Generate slide decks from briefs, docs, or outlines with PDF, PPTX, speaker notes, and structured slide metadata",
+    category: "Content Generation",
+    tags: ["presentation", "slides", "deck", "documents"]
+  },
+  {
+    name: "generate-qrcode",
+    displayName: "Generate QR Code",
+    description: "Generate QR codes with custom styling and embedded data",
+    category: "Content Generation",
+    tags: ["qrcode", "generation", "encoding", "visual"]
+  },
+  {
+    name: "generate-resume",
+    displayName: "Generate Resume",
+    description: "Generate professional resumes with formatting and content optimization",
+    category: "Content Generation",
+    tags: ["resume", "cv", "career", "generation"]
+  }
+];
+
+// src/lib/registry-data/finance-compliance.ts
+var FINANCE_COMPLIANCE_SKILLS = [
+  {
+    name: "contract-review-report",
+    displayName: "Contract Review Report",
+    description: "Generate contract review reports with risk register, clause summary, redline suggestions, negotiation email, and manifest artifacts",
+    category: "Finance & Compliance",
+    kind: "instruction",
+    tags: ["contract", "legal", "review", "risk"]
+  },
+  {
+    name: "invoice",
+    displayName: "Invoice",
+    description: "Generate professional invoices with company management and PDF export",
+    category: "Finance & Compliance",
+    tags: ["invoice", "billing", "pdf", "finance"]
+  },
+  {
+    name: "invoice-reconciliation",
+    displayName: "Invoice Reconciliation",
+    description: "Generate invoice reconciliation reports with matched payments, discrepancies, anomaly notes, summaries, and manifest artifacts",
+    category: "Finance & Compliance",
+    tags: ["invoice", "payments", "reconciliation", "finance"]
+  }
+];
+
+// src/lib/registry-data/data-analysis.ts
+var DATA_ANALYSIS_SKILLS = [
+  {
+    name: "analyze-data",
+    displayName: "Analyze Data",
+    description: "Data science insights for CSV and JSON datasets with statistical analysis",
+    category: "Data & Analysis",
+    tags: ["data", "analysis", "csv", "json", "statistics"]
+  },
+  {
+    name: "dashboard-builder",
+    displayName: "Dashboard Builder",
+    description: "Build data dashboards with charts, metrics, and visualizations",
+    category: "Data & Analysis",
+    tags: ["dashboard", "visualization", "charts", "metrics"]
+  },
+  {
+    name: "data-anonymizer",
+    displayName: "Data Anonymizer",
+    description: "Anonymize sensitive data in datasets for privacy compliance",
+    category: "Data & Analysis",
+    tags: ["anonymization", "privacy", "data", "compliance"]
+  },
+  {
+    name: "generate-chart",
+    displayName: "Generate Chart",
+    description: "Generate data charts and visualizations from datasets",
+    category: "Data & Analysis",
+    tags: ["charts", "visualization", "data", "graphs"]
+  },
+  {
+    name: "read-csv",
+    displayName: "Read CSV",
+    description: "Parse CSV files into structured JSON with delimiter and encoding detection",
+    category: "Data & Analysis",
+    tags: ["csv", "parsing", "tabular", "data"]
+  },
+  {
+    name: "read-excel",
+    displayName: "Read Excel",
+    description: "Parse XLS and XLSX workbooks into structured JSON with sheet and formatted cell metadata",
+    category: "Data & Analysis",
+    tags: ["excel", "spreadsheet", "xlsx", "data"]
+  },
+  {
+    name: "pdf-to-markdown",
+    displayName: "PDF to Markdown",
+    description: "Convert PDFs into clean markdown with remote extraction and structure cleanup",
+    category: "Data & Analysis",
+    tags: ["pdf", "markdown", "conversion"]
+  },
+  {
+    name: "pdf-to-dataset",
+    displayName: "PDF to Dataset",
+    description: "Extract PDF tables, forms, invoices, and semi-structured content into CSV and JSON datasets",
+    category: "Data & Analysis",
+    tags: ["pdf", "dataset", "csv", "json", "extraction"]
+  },
+  {
+    name: "doc-read",
+    displayName: "Doc Read",
+    description: "Read and extract text from DOCX files with section parsing and metadata extraction",
+    category: "Data & Analysis",
+    tags: ["docx", "reader", "extraction", "word"]
+  }
+];
+
+// src/lib/registry-data/media-processing.ts
+var MEDIA_PROCESSING_SKILLS = [
+  {
+    name: "video-highlight-pack",
+    displayName: "Video Highlight Pack",
+    description: "Generate video highlight packages with clip plans, captions, thumbnail briefs, chapter markers, social posts, and edit decisions",
+    category: "Media Processing",
+    kind: "instruction",
+    tags: ["video", "highlights", "clips", "captions"]
+  },
+  {
+    name: "compress-video",
+    displayName: "Compress Video",
+    description: "Compress video files while preserving visual quality using ffmpeg",
+    category: "Media Processing",
+    tags: ["video", "compression", "ffmpeg", "optimization"]
+  },
+  {
+    name: "audio-extract",
+    displayName: "Audio Extract",
+    description: "Extract audio tracks from video files with multiple format support",
+    category: "Media Processing",
+    tags: ["audio", "extraction", "video", "conversion"]
+  },
+  {
+    name: "extract-frames",
+    displayName: "Extract Frames",
+    description: "Extract frames from video files at specified intervals or timestamps",
+    category: "Media Processing",
+    tags: ["frames", "video", "extraction", "images"]
+  },
+  {
+    name: "gif-maker",
+    displayName: "GIF Maker",
+    description: "Create animated GIFs from images, videos, or screen recordings",
+    category: "Media Processing",
+    tags: ["gif", "animation", "images", "video"]
+  },
+  {
+    name: "video-downloader",
+    displayName: "Video Downloader",
+    description: "Download videos from various online platforms and services",
+    category: "Media Processing",
+    tags: ["video", "download", "platforms", "media"]
+  },
+  {
+    name: "watermark",
+    displayName: "Watermark",
+    description: "Add watermarks to images and documents for copyright protection",
+    category: "Media Processing",
+    tags: ["watermark", "protection", "copyright", "images"]
+  }
+];
+
+// src/lib/registry-data/design-branding.ts
+var DESIGN_BRANDING_SKILLS = [
+  {
+    name: "brand-kit",
+    displayName: "Brand Kit",
+    description: "Generate brand kits with logo usage, palette, typography, brand voice, sample applications, Markdown guide, PDF guide, and SVG assets",
+    category: "Design & Branding",
+    kind: "instruction",
+    tags: ["brand", "design", "palette", "typography"]
+  },
+  {
+    name: "brand-assets",
+    displayName: "Brand Assets",
+    description: "Fetch official brand assets from a website or brand name with logos, PNG sizes, palette, typography, source metadata, and manifests",
+    category: "Design & Branding",
+    tags: ["brand", "logo", "assets", "palette", "typography"]
+  },
+  {
+    name: "logo-design",
+    displayName: "Logo Design",
+    description: "Generate multi-variant logo packages with transparent PNGs, vector-style SVGs, usage notes, and manifests",
+    category: "Design & Branding",
+    tags: ["logo", "design", "branding", "identity"]
+  },
+  {
+    name: "generate-favicon",
+    displayName: "Generate Favicon",
+    description: "Generate favicons in multiple sizes and formats for websites",
+    category: "Design & Branding",
+    tags: ["favicon", "icon", "design", "web"]
+  },
+  {
+    name: "product-mockup",
+    displayName: "Product Mockup",
+    description: "Generate product mockup packages with visual variants, prompts, usage notes, and asset metadata",
+    category: "Design & Branding",
+    tags: ["product", "mockup", "visualization", "marketing"]
+  },
+  {
+    name: "siteanalyze",
+    displayName: "Site Analyze",
+    description: "Analyze any website's design system \u2014 detects shadcn/ui, Tailwind, extracts colors, typography, and components via Playwright + Claude Vision.",
+    category: "Design & Branding",
+    tags: ["design", "shadcn", "tailwind", "colors", "typography", "playwright", "analysis", "open-styles"]
+  }
+];
+
+// src/lib/registry-data/web-browser.ts
+var WEB_BROWSER_SKILLS = [
+  {
+    name: "domainpurchase",
+    displayName: "Domain Purchase",
+    description: "Purchase and manage domains via registrar connectors",
+    category: "Web & Browser",
+    tags: ["domain", "purchase", "registrar", "management"]
+  }
+];
+
+// src/lib/registry-data/research-writing.ts
+var RESEARCH_WRITING_SKILLS = [
+  {
+    name: "blog-article",
+    displayName: "Blog Article",
+    description: "Create SEO-optimized blog article artifact packages",
+    category: "Research & Writing",
+    kind: "instruction",
+    tags: ["blog", "article", "writing", "seo"]
+  },
+  {
+    name: "market-research-report",
+    displayName: "Market Research Report",
+    description: "Generate market research packages with competitor tables, positioning, pricing notes, source notes, and PDF/Markdown artifacts",
+    category: "Research & Writing",
+    kind: "instruction",
+    tags: ["market-research", "competitors", "positioning", "pricing", "report"]
+  }
+];
+
+// src/lib/registry-data/science-academic.ts
+var SCIENCE_ACADEMIC_SKILLS = [
+  {
+    name: "bio-sequence-tool",
+    displayName: "Bio Sequence Tool",
+    description: "Analyze and manipulate biological sequences including DNA, RNA, and protein data",
+    category: "Science & Academic",
+    tags: ["biology", "dna", "sequence", "bioinformatics"]
+  },
+  {
+    name: "experiment-power-calculator",
+    displayName: "Experiment Power Calculator",
+    description: "Calculate statistical power and sample size for experiments",
+    category: "Science & Academic",
+    tags: ["experiment", "statistics", "power-analysis", "sample-size"]
+  },
+  {
+    name: "latex-table-generator",
+    displayName: "LaTeX Table Generator",
+    description: "Generate formatted LaTeX tables from data for academic papers",
+    category: "Science & Academic",
+    tags: ["latex", "tables", "academic", "formatting"]
+  },
+  {
+    name: "scientific-figure-check",
+    displayName: "Scientific Figure Check",
+    description: "Validate scientific figures for accuracy, formatting, and publication standards",
+    category: "Science & Academic",
+    tags: ["scientific", "figures", "validation", "publishing"]
+  },
+  {
+    name: "statistical-test-selector",
+    displayName: "Statistical Test Selector",
+    description: "Recommend appropriate statistical tests based on data and research questions",
+    category: "Science & Academic",
+    tags: ["statistics", "test-selection", "research", "analysis"]
+  }
+];
+
+// src/lib/registry-data/education-learning.ts
+var EDUCATION_LEARNING_SKILLS = [];
+
+// src/lib/registry-data/communication.ts
+var COMMUNICATION_SKILLS = [];
+
+// src/lib/registry-data/health-wellness.ts
+var HEALTH_WELLNESS_SKILLS = [];
+
+// src/lib/registry-data/travel-lifestyle.ts
+var TRAVEL_LIFESTYLE_SKILLS = [];
+
+// src/lib/registry-data/event-management.ts
+var EVENT_MANAGEMENT_SKILLS = [];
+
+// src/lib/registry-data/index.ts
+var SKILLS = [
+  ...DEVELOPMENT_TOOLS_SKILLS,
+  ...BUSINESS_MARKETING_SKILLS,
+  ...PRODUCTIVITY_ORGANIZATION_SKILLS,
+  ...PROJECT_MANAGEMENT_SKILLS,
+  ...CONTENT_GENERATION_SKILLS,
+  ...FINANCE_COMPLIANCE_SKILLS,
+  ...DATA_ANALYSIS_SKILLS,
+  ...MEDIA_PROCESSING_SKILLS,
+  ...DESIGN_BRANDING_SKILLS,
+  ...WEB_BROWSER_SKILLS,
+  ...RESEARCH_WRITING_SKILLS,
+  ...SCIENCE_ACADEMIC_SKILLS,
+  ...EDUCATION_LEARNING_SKILLS,
+  ...COMMUNICATION_SKILLS,
+  ...HEALTH_WELLNESS_SKILLS,
+  ...TRAVEL_LIFESTYLE_SKILLS,
+  ...EVENT_MANAGEMENT_SKILLS
+];
+
+// src/lib/hosted-skill-set.ts
+var HOSTED_RUNTIMES = new Set(["hosted"]);
+var HOSTED_SOURCES = new Set(["remote", "private-hosted"]);
+var HOSTED_METADATA_SET_EMPTY_ERROR = [
+  "The hosted metadata skill set is empty, but the packaging guards that depend on it",
+  "only mean anything while it is non-empty: an empty set makes every one of them pass",
+  "vacuously and silently removes the protection that keeps hosted implementation source",
+  "out of the published package.",
+  "",
+  "If emptying the set is intentional (every hosted skill was deleted or converted to a",
+  "runnable in-repo skill), retire the derived guards in the SAME change \u2014 do not let them",
+  "stay green and empty."
+].join(`
+`);
+var SLUG = "[^,{}/]+";
+var BRACE_SOURCE_EXCLUSION = new RegExp(`^!skills/\\{(${SLUG}(?:,${SLUG})+)\\}/src$`);
+var SINGLE_SOURCE_EXCLUSION = new RegExp(`^!skills/(${SLUG})/src$`);
+
+// src/lib/skill-validation.ts
+var RESERVED_SKILL_ENTRIES = new Set([
+  ".env",
+  ".npmrc",
+  ".pypirc",
+  ".netrc",
+  "id_rsa",
+  "id_ed25519"
+]);
+var KNOWN_TOP_LEVEL_ENTRIES = new Set([
+  ".claude",
+  ".env.example",
+  ".gitignore",
+  ".skills",
+  "CLAUDE.md",
+  "AGENTS.md",
+  "LICENSE",
+  "PROJECT_OVERVIEW.md",
+  "QUICKSTART.md",
+  "README.md",
+  "SKILL.md",
+  "api-docs-list.json",
+  "auth.ts",
+  "bun.lock",
+  "bunfig.toml",
+  "data",
+  "dist",
+  "examples",
+  "exports",
+  "http-client.ts",
+  "index.ts",
+  "install.sh",
+  "installer.ts",
+  "logs",
+  "node_modules",
+  "package.json",
+  "scripts",
+  "skill-install.ts",
+  "skill.json",
+  "src",
+  "tests",
+  "references",
+  "assets",
+  "tsconfig.json",
+  "vision.ts"
+]);
+var VALID_PROVENANCE_SOURCES = new Set(["official", "custom", "remote", "private", "private-hosted", "upstream", "extension"]);
+
+// src/lib/portable-skills-files.ts
+var ANY_SEGMENT_COPY_EXCLUDES = new Set([
+  ".git",
+  ".DS_Store",
+  ".system",
+  "node_modules"
+]);
+var FIRST_SEGMENT_COPY_EXCLUDES = new Set([
+  "dist",
+  "build",
+  ".turbo"
+]);
+// src/lib/portable-skills.ts
+var OFFICIAL_SKILL_NAMES = new Set(SKILLS.map((skill) => skill.name));
+// src/lib/installer.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4, rmSync } from "fs";
+import { dirname as dirname6, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/lib/agent-sync.ts
+import { basename, dirname as dirname5, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+
+// src/lib/installer.ts
+var __dirname3 = dirname6(fileURLToPath3(import.meta.url));
+function findSkillsDir() {
+  let dir = __dirname3;
+  for (let i3 = 0;i3 < 5; i3++) {
+    const candidate = join7(dir, "skills");
+    if (existsSync3(candidate) && !dir.includes(".skills"))
+      return candidate;
+    dir = dirname6(dir);
+  }
+  return join7(__dirname3, "..", "skills");
+}
+var SKILLS_DIR = findSkillsDir();
+
+// src/server/skills-api.ts
+var MAX_SKILL_MD_BYTES = 512000;
+var MAX_MANIFEST_BYTES = MAX_SKILL_MD_BYTES + 64000;
+var ALLOWED_PUBLISH_PARTS = new Set(["manifest", "bundle"]);
+
+// src/server/app.ts
+function assertDurableStore(store, config) {
+  const backend = store.backend;
+  if (!backend || backend.durable)
+    return;
+  assertDurableTarget(backend, config);
+}
+function assertDurableTarget(target, config) {
+  if (target.durable || config.allowEphemeralStore)
+    return;
+  throw new Error(`refusing to start: the configured store is ${target.label} and does not survive a restart. ` + "Leave HASNA_SKILLS_DATABASE_URL unset to use the durable SQLite database in the skills data " + "directory, or point it at a postgres:// URL. Set HASNA_SKILLS_ALLOW_EPHEMERAL_STORE=1 only if " + "losing every run on restart is genuinely what you want.");
+}
+
 // src/server/worker.ts
-async function runWorkerOnce(store, workerId = `worker_${randomUUID2().slice(0, 8)}`, storage = new ArtifactStorage) {
+async function runWorkerOnce(store, workerId = `worker_${randomUUID4().slice(0, 8)}`, storage = new ArtifactStorage) {
   const run = await store.claimNextRun({ workerId });
   if (!run)
     return false;
@@ -30922,16 +32845,31 @@ async function runWorkerOnce(store, workerId = `worker_${randomUUID2().slice(0,
 if (import.meta.main) {
   const config = resolveServerConfig();
   const store = await createStore({ databaseUrl: config.databaseUrl, bootstrapApiKey: config.bootstrapApiKey });
+  assertDurableStore(store, config);
   const storage = new ArtifactStorage({ bucket: config.artifactBucket, prefix: config.artifactPrefix });
-  const workerId = process.env.HASNA_SKILLS_WORKER_ID || `worker_${randomUUID2().slice(0, 8)}`;
+  console.log(`skills worker ${process.env.HASNA_SKILLS_WORKER_ID || ""} storage: ${resolveDatabaseTarget(config.databaseUrl).label}`);
+  const workerId = process.env.HASNA_SKILLS_WORKER_ID || `worker_${randomUUID4().slice(0, 8)}`;
   const once = process.argv.includes("--once");
   const idleMs = Number.parseInt(process.env.HASNA_SKILLS_WORKER_IDLE_MS || "1000", 10);
+  const pause = Number.isFinite(idleMs) ? idleMs : 1000;
+  let consecutiveErrors = 0;
   do {
-    const processed = await runWorkerOnce(store, workerId, storage);
+    let processed = false;
+    try {
+      processed = await runWorkerOnce(store, workerId, storage);
+      consecutiveErrors = 0;
+    } catch (error) {
+      consecutiveErrors += 1;
+      console.error(`worker ${workerId}: claim/execute failed (${consecutiveErrors} in a row):`, error.message);
+      if (once)
+        process.exit(1);
+      await new Promise((resolve) => setTimeout(resolve, Math.min(pause * consecutiveErrors, 30000)));
+      continue;
+    }
     if (once)
       process.exit(processed ? 0 : 2);
     if (!processed)
-      await new Promise((resolve) => setTimeout(resolve, Number.isFinite(idleMs) ? idleMs : 1000));
+      await new Promise((resolve) => setTimeout(resolve, pause));
   } while (true);
 }
 export {