@hasna/skills 0.1.60 → 0.1.62

package/dist/lib/vendor-host-url.d.ts

@@ -0,0 +1,81 @@
+export interface Sentinels {
+    /** Stands for `{…}` / `${…}` template syntax inside a single literal. */
+    placeholder: string;
+    /** Stands for a value computed by code (a non-constant concatenation operand). */
+    hole: string;
+}
+/**
+ * Normalise text before any URL is read out of it.
+ *
+ *  - Private Use Area characters are removed, so sentinels stay out of band.
+ *  - Tab, LF and CR are removed because the WHATWG URL parser removes them
+ *    before parsing: `https://example.com\n@vendor.invalid/x` is a request to
+ *    vendor.invalid with `example.com` as userinfo, and a scanner that stops at the
+ *    newline reads the opposite of what the runtime does.
+ */
+export declare function sanitizeForScanning(text: string): string;
+/**
+ * Sanitiser for free text (Markdown, JSON, shell, dotenv).
+ *
+ * Deliberately does NOT strip newlines. Removing them is right inside a single
+ * URL string, where the runtime parser removes them too; applied to a whole
+ * file it concatenates unrelated lines, and a verbatim `https://vendor.invalid` at
+ * end-of-line became `vendor.invalidUse` — invisible to every host rule.
+ */
+export declare function sanitizeProseForScanning(text: string): string;
+/**
+ * Two distinct sentinel characters.
+ *
+ * They are not searched for: `sanitizeForScanning` deletes the whole Private Use
+ * Area from every literal as it is read, so these characters cannot appear in
+ * the input and no per-input search is needed.
+ */
+export declare function pickSentinels(): Sentinels;
+export interface UrlReference {
+    /** The matched URL, trimmed of trailing punctuation. Sentinels removed. */
+    url: string;
+    /** Host as far as it is statically known, with sentinels still in place. */
+    markedHost: string;
+    /** Registrable domain, or undefined when it cannot be determined statically. */
+    domain?: string;
+    /** When `domain` is undefined, what supplied the undeterminable tail. */
+    undeterminedBy?: "placeholder" | "hole";
+}
+export declare function stripSentinels(text: string, sentinels: Sentinels): string;
+/**
+ * Every absolute http(s) URL in a blob of text.
+ *
+ * `text` is expected to be already sentinel-marked when it came from folding.
+ * Placeholder syntax inside the text is masked here so that a `{…}` body
+ * containing `/`, `?` or `#` cannot cut the authority in half.
+ */
+export declare function extractUrlReferences(text: string, sentinels?: Sentinels): UrlReference[];
+export interface ScanSource {
+    /** Package-relative path, used for reporting. */
+    file: string;
+    content: string;
+    /** Set when the bytes could not be decoded as text; `content` is then empty. */
+    undecodable?: string;
+}
+export interface VendorHostFinding {
+    file: string;
+    url: string;
+    host: string;
+}
+/**
+ * Find known vendor domains even when they do not appear in a complete URL.
+ */
+export declare function findVendorDomainTokens(text: string): {
+    domain: string;
+    index: number;
+}[];
+/**
+ * WEAK backstop: known vendor domains anywhere in the shipped bytes.
+ *
+ * A denylist over raw text. It cannot see a vendor domain that is not on
+ * `VENDOR_CONTROLLED_DOMAINS`, and it cannot see a host split across string
+ * literals. Both gaps are closed for executable code by `findDisallowedCodeUrls`,
+ * which folds constants and works from an allowlist. This check exists for prose,
+ * which cannot issue a request.
+ */
+export declare function findVendorHostReferences(sources: Iterable<ScanSource>): VendorHostFinding[];

package/dist/mcp/mcp-test-client.d.ts

@@ -0,0 +1,18 @@
+export declare const EXPECTED_ALL_SKILL_COUNT: number;
+export declare const EXPECTED_BASIC_SKILL_COUNT: 8;
+/**
+ * Helper class to communicate with the MCP server over stdio.
+ */
+export declare class McpClient {
+    private proc;
+    private buffer;
+    private messages;
+    private reader;
+    constructor(env?: Record<string, string>);
+    private _readLoop;
+    send(msg: any): void;
+    waitForMessage(id: number, timeout?: number): Promise<any>;
+    initialize(): Promise<void>;
+    request(method: string, params?: Record<string, unknown>, id?: number): Promise<any>;
+    close(): Promise<void>;
+}

package/dist/storage.d.ts

@@ -1 +1 @@
-export { SKILLS_NATIVE_STORAGE_ENV, SKILLS_NATIVE_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_ENV, SKILLS_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_TABLES, STORAGE_TABLES, SkillsPostgresSyncStore, SkillsS3ObjectStore, buildSkillsS3ObjectUrl, createSkillsPostgresSyncStore, createSkillsS3ObjectStore, createSkillsSnapshotSyncRecord, exportSkillsLocalSnapshot, getSkillsNativeStorageStatus, getSkillsStorageDatabaseEnv, getSkillsStorageDatabaseUrl, getSkillsStorageMode, getSkillsStorageStatus, getStorageDatabaseEnv, getStorageDatabaseUrl, getStorageMode, getStorageStatus, importSkillsLocalSnapshot, planSkillsS3SnapshotUpload, resolveSkillsNativeStorageConfig, resolveStorageConfig, signSkillsAwsV4Request, skillsPostgresSyncSchemaSql, uploadSkillsSnapshotFilesToS3, type AwsCredentials, type SignSkillsAwsV4RequestOptions, type SkillsFetch, type SkillsLocalSnapshot, type SkillsNativeStorageConfig, type SkillsNativeStorageStatus, type SkillsPostgresQueryClient, type SkillsS3ObjectStoreOptions, type SkillsS3PutObjectOptions, type SkillsS3SnapshotPlanEntry, type SkillsS3StoredObject, type SkillsSnapshotFile, type SkillsStorageMode, type SkillsStorageTable, type SkillsSyncRecord, } from "./lib/native-storage.js";
+export { SKILLS_NATIVE_STORAGE_ENV, SKILLS_NATIVE_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_ENV, SKILLS_STORAGE_FALLBACK_ENV, SKILLS_STORAGE_TABLES, STORAGE_TABLES, SkillsPostgresSyncStore, SkillsS3ObjectStore, buildSkillsS3ObjectUrl, createSkillsPostgresSyncStore, createSkillsS3ObjectStore, createSkillsSnapshotSyncRecord, exportSkillsLocalSnapshot, getSkillsNativeStorageStatus, getSkillsStorageDatabaseEnv, getSkillsStorageDatabaseUrl, getSkillsStorageStatus, getStorageDatabaseEnv, getStorageDatabaseUrl, getStorageStatus, importSkillsLocalSnapshot, planSkillsS3SnapshotUpload, resolveSkillsNativeStorageConfig, resolveStorageConfig, signSkillsAwsV4Request, skillsPostgresSyncSchemaSql, uploadSkillsSnapshotFilesToS3, type AwsCredentials, type SignSkillsAwsV4RequestOptions, type SkillsFetch, type SkillsLocalSnapshot, type SkillsNativeStorageConfig, type SkillsNativeStorageStatus, type SkillsPostgresQueryClient, type SkillsS3ObjectStoreOptions, type SkillsS3PutObjectOptions, type SkillsS3SnapshotPlanEntry, type SkillsS3StoredObject, type SkillsSnapshotFile, type SkillsStorageTable, type SkillsSyncRecord, } from "./lib/native-storage.js";

package/dist/storage.js

@@ -30,29 +30,64 @@ import { dirname as dirname2, join as join3, normalize, relative, sep } from "pa
 import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, readdirSync, statSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
+
+// src/lib/retired-settings.ts
+var RETIRED_ENV_SUFFIXES = ["_STORAGE_MODE", "_DEPLOYMENT_MODE", "_CLOUD_MODE"];
+var RETIRED_CONFIG_KEYS = {
+  mode: "apiUrl"
+};
+
+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((a, b) => a.name.localeCompare(b.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.");
+}
+function assertNoRetiredConfigKeys(config, source) {
+  for (const [key, replacement] of Object.entries(RETIRED_CONFIG_KEYS)) {
+    if (!(key in config))
+      continue;
+    throw new RetiredSettingError(key, `${source}: "${key}" is no longer a configuration key. ` + "Deployment modes were removed: a Skills client either has an API origin " + "configured or it does not, and that is the whole of it. " + `Use "${replacement}" instead (skills config set ${replacement} <origin>), and ` + `remove the old key with: skills config unset ${key}. ` + "Refused rather than ignored, because silently dropping it would leave an " + "operator believing they had pointed this install at a server.");
+  }
+}
+
+// src/lib/config.ts
 var ENUM_KEYS = {
   defaultAgent: ["claude", "codex", "gemini", "pi", "opencode", "all"],
   defaultScope: ["global", "project"],
   format: ["compact", "json", "csv"]
 };
-var STRING_KEYS = ["apiUrl"];
-var MODE_VALUES = ["local", "self-hosted"];
-var MODE_ALIASES = {
-  local: "local",
-  offline: "local",
-  "self-hosted": "self-hosted",
-  selfhosted: "self-hosted",
-  self_hosted: "self-hosted",
-  hosted: "self-hosted",
-  "skills.md": "self-hosted",
-  skillsmd: "self-hosted"
-};
+var STRING_KEYS = ["apiUrl", "extensionsDir"];
 function validKeys() {
-  return ["mode", ...Object.keys(ENUM_KEYS), ...STRING_KEYS];
+  return [...Object.keys(ENUM_KEYS), ...STRING_KEYS];
 }
 function allowedValues(key) {
-  if (key === "mode")
-    return MODE_VALUES;
   return ENUM_KEYS[key];
 }
 function mergeDirectoryContents(sourceDir, targetDir) {
@@ -76,8 +111,6 @@ function mergeDirectoryContents(sourceDir, targetDir) {
 function normalizeConfigValue(key, value) {
   if (typeof value !== "string")
     return;
-  if (key === "mode")
-    return MODE_ALIASES[value.trim().toLowerCase()];
   const allowed = allowedValues(key);
   if (allowed)
     return allowed.includes(value) ? value : undefined;
@@ -91,9 +124,20 @@ function normalizeConfigValue(key, value) {
       return;
     }
   }
+  if (key === "extensionsDir")
+    return value.trim() ? value : undefined;
   return;
 }
+var DATA_DIR_ENV = "HASNA_SKILLS_DIR";
+var INSTALLED_SKILLS_DIRNAME = "installed";
 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"] || homedir();
   const newDir = join(home, ".hasna", "skills");
   const oldDir = join(home, ".skills");
@@ -118,21 +162,22 @@ function getConfigPath(scope) {
 function readConfigFile(path) {
   if (!existsSync(path))
     return {};
+  let parsed;
   try {
-    const raw = readFileSync(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
-      return {};
-    const config = {};
-    for (const key of validKeys()) {
-      const value = normalizeConfigValue(key, parsed[key]);
-      if (value !== undefined)
-        config[key] = value;
-    }
-    return config;
+    parsed = JSON.parse(readFileSync(path, "utf-8"));
   } catch {
     return {};
   }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return {};
+  assertNoRetiredConfigKeys(parsed, path);
+  const config = {};
+  for (const key of validKeys()) {
+    const value = normalizeConfigValue(key, parsed[key]);
+    if (value !== undefined)
+      config[key] = value;
+  }
+  return config;
 }
 function loadConfig() {
   const globalConfig = readConfigFile(getConfigPath("global"));
@@ -140,13 +185,14 @@ function loadConfig() {
   return { ...globalConfig, ...projectConfig };
 }
 function saveConfig(key, value, scope = "project") {
+  assertNoRetiredConfigKeys({ [key]: value }, `config set ${key}`);
   if (!validKeys().includes(key)) {
     throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
   }
   const normalized = normalizeConfigValue(key, value);
   if (normalized === undefined) {
     const allowed = allowedValues(key);
-    throw new Error(allowed ? `Invalid value '${value}' for ${key}. Allowed: ${allowed.join(", ")}` : `Invalid value '${value}' for ${key}. Expected an http(s) URL`);
+    throw new Error(allowed ? `Invalid value '${value}' for ${key}. Allowed: ${allowed.join(", ")}` : `Invalid value '${value}' for ${key}. Expected ${key === "apiUrl" ? "an http(s) URL" : "a non-empty path"}`);
   }
   const filePath = getConfigPath(scope);
   let existing = {};
@@ -165,10 +211,34 @@ function saveConfig(key, value, scope = "project") {
       mkdirSync(dir, { recursive: true });
     }
   }
+  assertNoRetiredConfigKeys(existing, filePath);
   existing[key] = normalized;
   writeFileSync(filePath, JSON.stringify(existing, null, 2) + `
 `);
 }
+function unsetConfig(key, scope = "project") {
+  if (!validKeys().includes(key) && !(key in RETIRED_CONFIG_KEYS)) {
+    throw new Error(`Unknown config key: ${key}. Valid keys: ${validKeys().join(", ")}`);
+  }
+  const filePath = getConfigPath(scope);
+  if (!existsSync(filePath))
+    return false;
+  let existing;
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return false;
+    existing = parsed;
+  } catch {
+    return false;
+  }
+  if (!(key in existing))
+    return false;
+  delete existing[key];
+  writeFileSync(filePath, JSON.stringify(existing, null, 2) + `
+`);
+  return true;
+}
 
 // src/lib/project-state.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -324,7 +394,6 @@ var SKILLS_STORAGE_TABLES = [
 ];
 var STORAGE_TABLES = SKILLS_STORAGE_TABLES;
 var SKILLS_NATIVE_STORAGE_ENV = {
-  mode: "HASNA_SKILLS_STORAGE_MODE",
   databaseUrl: "HASNA_SKILLS_DATABASE_URL",
   databaseSsl: "HASNA_SKILLS_DATABASE_SSL",
   databaseSchema: "HASNA_SKILLS_DATABASE_SCHEMA",
@@ -340,7 +409,6 @@ var SKILLS_NATIVE_STORAGE_ENV = {
   dryRun: "HASNA_SKILLS_SYNC_DRY_RUN"
 };
 var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
-  mode: "SKILLS_STORAGE_MODE",
   databaseUrl: "SKILLS_DATABASE_URL",
   databaseSsl: "SKILLS_DATABASE_SSL",
   databaseSchema: "SKILLS_DATABASE_SCHEMA",
@@ -357,10 +425,13 @@ var SKILLS_NATIVE_STORAGE_FALLBACK_ENV = {
 };
 var SKILLS_STORAGE_ENV = SKILLS_NATIVE_STORAGE_ENV;
 var SKILLS_STORAGE_FALLBACK_ENV = SKILLS_NATIVE_STORAGE_FALLBACK_ENV;
+var SKILLS_ENV_NAMESPACE = "SKILLS";
 function resolveSkillsNativeStorageConfig(env = process.env) {
-  const mode = getSkillsStorageMode(env);
+  assertNoRetiredModeEnvVars(env, {
+    app: SKILLS_ENV_NAMESPACE,
+    replacement: SKILLS_NATIVE_STORAGE_ENV.databaseUrl
+  });
   return {
-    mode,
     databaseUrl: getSkillsStorageDatabaseUrl(env),
     databaseSsl: parseBoolean(readStorageEnv(env, "databaseSsl").value),
     databaseSchema: readStorageEnv(env, "databaseSchema").value,
@@ -376,12 +447,6 @@ function resolveSkillsNativeStorageConfig(env = process.env) {
 function resolveStorageConfig(env = process.env) {
   return resolveSkillsNativeStorageConfig(env);
 }
-function getSkillsStorageMode(env = process.env) {
-  return parseMode(readStorageEnv(env, "mode").value);
-}
-function getStorageMode(env = process.env) {
-  return getSkillsStorageMode(env);
-}
 function getSkillsStorageDatabaseEnv(env = process.env) {
   return readStorageEnv(env, "databaseUrl").name;
 }
@@ -397,16 +462,13 @@ function getStorageDatabaseUrl(env = process.env) {
 function getSkillsNativeStorageStatus(options = {}) {
   const env = options.env ?? process.env;
   const config = resolveSkillsNativeStorageConfig(env);
-  const modeEnv = readStorageEnv(env, "mode");
   const databaseEnv = readStorageEnv(env, "databaseUrl");
   const s3BucketEnv = readStorageEnv(env, "s3Bucket");
   const targetDir = options.targetDir ?? process.cwd();
   return {
     package: "open-skills",
-    mode: config.mode,
     tables: [...SKILLS_STORAGE_TABLES],
     env: {
-      mode: SKILLS_NATIVE_STORAGE_ENV.mode,
       databaseUrl: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
       s3Bucket: SKILLS_NATIVE_STORAGE_ENV.s3Bucket
     },
@@ -420,7 +482,6 @@ function getSkillsNativeStorageStatus(options = {}) {
       s3Configured: Boolean(config.s3Bucket),
       databaseEnv: SKILLS_NATIVE_STORAGE_ENV.databaseUrl,
       s3BucketEnv: SKILLS_NATIVE_STORAGE_ENV.s3Bucket,
-      activeModeEnv: modeEnv.name,
       activeDatabaseEnv: databaseEnv.name,
       activeS3BucketEnv: s3BucketEnv.name,
       region: config.awsRegion ?? "us-east-1",
@@ -737,12 +798,6 @@ function buildSkillsS3ObjectUrl(params) {
   }
   return params.forcePathStyle ? `https://s3.${region}.amazonaws.com/${encodeURIComponent(params.bucket)}/${key}` : `https://${params.bucket}.s3.${region}.amazonaws.com/${key}`;
 }
-function parseMode(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (normalized === "remote" || normalized === "hybrid")
-    return normalized;
-  return "local";
-}
 function readStorageEnv(env, key) {
   const primaryName = SKILLS_NATIVE_STORAGE_ENV[key];
   const primaryValue = cleanOptional(env[primaryName]);
@@ -863,11 +918,9 @@ export {
   planSkillsS3SnapshotUpload,
   importSkillsLocalSnapshot,
   getStorageStatus,
-  getStorageMode,
   getStorageDatabaseUrl,
   getStorageDatabaseEnv,
   getSkillsStorageStatus,
-  getSkillsStorageMode,
   getSkillsStorageDatabaseUrl,
   getSkillsStorageDatabaseEnv,
   getSkillsNativeStorageStatus,

package/docs/skill-standard.md

@@ -37,7 +37,7 @@ Minimum `SKILL.md` frontmatter for an instruction skill:
 
 ```yaml
 ---
-name: skill-project
+name: project
 description: Open or resume an existing Hasna repo project using the projects CLI.
 kind: instruction
 version: 0.1.0

package/migrations/postgres/0002_org_scoped_skill_registry.sql

@@ -0,0 +1,72 @@
+-- Org-scope the skill registry and give it content-addressed bundle storage.
+--
+-- 0001 declared skills_registry with `slug` as its whole primary key, no org_id, and no
+-- reference to any stored content. Nothing in src/ ever read or wrote it. Publishing
+-- makes it real, and a published skill is tenant data: two organizations on one instance
+-- must both be able to publish `deploy-notes` without colliding, and neither may read the
+-- other's. That makes the primary key (org_id, slug).
+--
+-- The table is DROPPED and recreated rather than altered. A primary key cannot be
+-- redefined by ALTER TABLE in SQLite at all, and the two dialect files must declare the
+-- same shape, so an ALTER-based Postgres migration and a rebuild-based SQLite one would
+-- diverge in exactly the way the parallel set exists to prevent.
+--
+-- Dropping is safe only because the table has never had a writer - `grep -rn
+-- skills_registry src/` before this migration found one reference, in the schema-parity
+-- test's table list - so there is no row anywhere whose owning organization we would have
+-- to invent. That is stated rather than assumed, because the identical statement would be
+-- data loss the day after this migration ships.
+DROP TABLE IF EXISTS skills_registry;
+
+-- Bundle bytes, addressed by content.
+--
+-- Separate from skills_registry for two reasons. Content addressing is only real if two
+-- rows that happen to hold identical bytes share one blob, which requires the digest to
+-- be the key. And listing an org's skills must not drag megabytes of tarball through the
+-- row mapper to render a name and a description.
+--
+-- Scoped by org even though a digest is globally unique: a bundle is a tenant's source
+-- code, and deduplicating across tenants would let org B confirm the exact contents of
+-- org A's private skill by uploading a guess and watching for a shared row.
+CREATE TABLE IF NOT EXISTS skills_bundles (
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  sha256 text NOT NULL,
+  byte_size integer NOT NULL,
+  content_type text NOT NULL DEFAULT 'application/gzip',
+  storage_kind text NOT NULL DEFAULT 'db',
+  storage_key text,
+  -- bytea, not text. A skill bundle is a gzipped tar; skills_artifacts.body_text could
+  -- stay text because a run artifact is a document, but there is no encoding under which
+  -- a tarball survives a text column intact.
+  body_blob bytea,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY (org_id, sha256)
+);
+
+CREATE TABLE IF NOT EXISTS skills_registry (
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  slug text NOT NULL,
+  display_name text NOT NULL,
+  description text NOT NULL DEFAULT '',
+  category text NOT NULL DEFAULT 'Remote',
+  tags_json jsonb NOT NULL DEFAULT '[]'::jsonb,
+  source text NOT NULL DEFAULT 'custom',
+  kind text NOT NULL DEFAULT 'executable',
+  version text,
+  -- The agent-facing document, kept alongside the metadata so GET /skills/:slug/skill.md
+  -- can answer for a published skill without the server ever unpacking a tarball.
+  skill_md text,
+  -- Soft reference to skills_bundles(org_id, sha256). Deliberately not a composite
+  -- foreign key: the only usable ON DELETE action for it would be SET NULL, which on a
+  -- composite key would also null org_id, and org_id is NOT NULL. Orphan collection is an
+  -- application-level concern (deleteSkill drops a bundle no remaining row references).
+  bundle_sha256 text,
+  bundle_byte_size integer,
+  published_by_user_id text REFERENCES users(id) ON DELETE SET NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY (org_id, slug),
+  CHECK (kind IN ('executable','instruction'))
+);
+
+CREATE INDEX IF NOT EXISTS skills_registry_org_updated_idx ON skills_registry (org_id, updated_at DESC);

package/migrations/sqlite/0001_open_skills_self_hosted.sql

@@ -0,0 +1,150 @@
+-- SQLite dialect of 0001_open_skills_self_hosted.
+--
+-- This is a hand-written parallel of migrations/postgres/0001_open_skills_self_hosted.sql,
+-- not a translation produced at runtime. The two files MUST declare the same schema
+-- *shape* - same tables, same column names, same primary keys, same NOT NULL columns,
+-- same uniqueness constraints, same foreign keys, same status domain - because the
+-- org-scoped data model is the OSS layer's and is not per-backend negotiable.
+-- src/server/schema-parity.test.ts executes this file and compares the result against
+-- the parsed Postgres DDL, so drift fails CI rather than surfacing as a cross-backend
+-- behaviour difference in production.
+--
+-- Deliberate, shape-preserving dialect differences:
+--   * pgcrypto is not created - no column defaults to a database-generated UUID; every
+--     id is minted in TypeScript (runId()/artifactId()/randomUUID()) for both backends.
+--   * timestamptz -> text holding a UTC ISO-8601 instant. strftime('...%fZ','now')
+--     produces exactly the format Date#toISOString() emits, so values written by raw
+--     SQL and values written by the store are byte-identical and sort lexicographically
+--     in the same order timestamptz sorts chronologically.
+--   * jsonb -> text holding JSON. The row mappers already accept either a parsed object
+--     or a JSON string (parseJsonObject/parseJsonArray in store.ts), so one mapper
+--     serves both backends.
+--   * bigserial -> integer PRIMARY KEY AUTOINCREMENT, SQLite's monotonic surrogate key.
+
+CREATE TABLE IF NOT EXISTS organizations (
+  id text PRIMARY KEY,
+  slug text NOT NULL UNIQUE,
+  name text NOT NULL,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS users (
+  id text PRIMARY KEY,
+  email text NOT NULL UNIQUE,
+  name text,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS organization_members (
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  user_id text NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  role text NOT NULL DEFAULT 'owner',
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  PRIMARY KEY (org_id, user_id)
+);
+
+CREATE TABLE IF NOT EXISTS api_keys (
+  id text PRIMARY KEY,
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  user_id text NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  name text NOT NULL,
+  key_hash text NOT NULL UNIQUE,
+  scopes_json text NOT NULL DEFAULT '["skills:read","runs:write"]',
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  last_used_at text,
+  revoked_at text
+);
+
+CREATE TABLE IF NOT EXISTS skills_registry (
+  slug text PRIMARY KEY,
+  display_name text NOT NULL,
+  description text NOT NULL DEFAULT '',
+  category text NOT NULL DEFAULT 'Remote',
+  tags_json text NOT NULL DEFAULT '[]',
+  source text NOT NULL DEFAULT 'bundled',
+  version text,
+  updated_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS skills_runs (
+  id text PRIMARY KEY,
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  user_id text NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  skill_slug text NOT NULL,
+  requested_slug text NOT NULL,
+  status text NOT NULL,
+  input_json text NOT NULL DEFAULT '{}',
+  args_json text NOT NULL DEFAULT '[]',
+  idempotency_key text,
+  correlation_id text NOT NULL,
+  cost_cents integer NOT NULL DEFAULT 0,
+  output_type text,
+  output_preview text,
+  error_code text,
+  error_message text,
+  locked_by text,
+  locked_at text,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  started_at text,
+  completed_at text,
+  CHECK (status IN ('queued','waiting_for_approval','running','succeeded','failed','cancel_requested','cancelled','retrying','expired','refunded'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS skills_runs_org_idempotency_idx
+  ON skills_runs (org_id, idempotency_key)
+  WHERE idempotency_key IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS skills_runs_org_created_idx ON skills_runs (org_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS skills_runs_status_created_idx ON skills_runs (status, created_at ASC);
+
+CREATE TABLE IF NOT EXISTS skills_run_logs (
+  id integer PRIMARY KEY AUTOINCREMENT,
+  run_id text NOT NULL REFERENCES skills_runs(id) ON DELETE CASCADE,
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  sequence integer NOT NULL,
+  level text NOT NULL DEFAULT 'info',
+  message text NOT NULL,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  UNIQUE (run_id, sequence)
+);
+
+CREATE TABLE IF NOT EXISTS skills_artifacts (
+  id text PRIMARY KEY,
+  run_id text NOT NULL REFERENCES skills_runs(id) ON DELETE CASCADE,
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  file_name text NOT NULL,
+  relative_path text NOT NULL,
+  content_type text NOT NULL,
+  byte_size integer NOT NULL,
+  sha256 text NOT NULL,
+  storage_kind text NOT NULL DEFAULT 'db',
+  storage_key text,
+  body_text text,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS skills_artifacts_run_idx ON skills_artifacts (run_id);
+
+CREATE TABLE IF NOT EXISTS skills_approvals (
+  id text PRIMARY KEY,
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  run_id text REFERENCES skills_runs(id) ON DELETE CASCADE,
+  approved_by_user_id text REFERENCES users(id) ON DELETE SET NULL,
+  policy_digest text NOT NULL,
+  status text NOT NULL,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  decided_at text,
+  CHECK (status IN ('pending','approved','rejected','expired'))
+);
+
+CREATE TABLE IF NOT EXISTS skills_audit_events (
+  id integer PRIMARY KEY AUTOINCREMENT,
+  org_id text REFERENCES organizations(id) ON DELETE SET NULL,
+  user_id text REFERENCES users(id) ON DELETE SET NULL,
+  api_key_id text REFERENCES api_keys(id) ON DELETE SET NULL,
+  action text NOT NULL,
+  target_type text NOT NULL,
+  target_id text,
+  metadata_json text NOT NULL DEFAULT '{}',
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);

package/migrations/sqlite/0002_org_scoped_skill_registry.sql

@@ -0,0 +1,47 @@
+-- SQLite dialect of 0002_org_scoped_skill_registry.
+--
+-- Hand-written parallel of migrations/postgres/0002_org_scoped_skill_registry.sql. Read
+-- that file for why the registry is org-scoped and why the table is dropped rather than
+-- altered; the rationale is not repeated here, only the dialect differences are.
+--
+-- Deliberate, shape-preserving dialect differences (same set as 0001):
+--   * timestamptz -> text holding a UTC ISO-8601 instant.
+--   * jsonb       -> text holding JSON.
+--   * bytea       -> blob. Both are "opaque bytes"; bun:sqlite round-trips a Uint8Array
+--                    through a blob column and Bun's SQL client round-trips one through
+--                    bytea, so the store hands the same Uint8Array to either backend.
+DROP TABLE IF EXISTS skills_registry;
+
+CREATE TABLE IF NOT EXISTS skills_bundles (
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  sha256 text NOT NULL,
+  byte_size integer NOT NULL,
+  content_type text NOT NULL DEFAULT 'application/gzip',
+  storage_kind text NOT NULL DEFAULT 'db',
+  storage_key text,
+  body_blob blob,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  PRIMARY KEY (org_id, sha256)
+);
+
+CREATE TABLE IF NOT EXISTS skills_registry (
+  org_id text NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+  slug text NOT NULL,
+  display_name text NOT NULL,
+  description text NOT NULL DEFAULT '',
+  category text NOT NULL DEFAULT 'Remote',
+  tags_json text NOT NULL DEFAULT '[]',
+  source text NOT NULL DEFAULT 'custom',
+  kind text NOT NULL DEFAULT 'executable',
+  version text,
+  skill_md text,
+  bundle_sha256 text,
+  bundle_byte_size integer,
+  published_by_user_id text REFERENCES users(id) ON DELETE SET NULL,
+  created_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  updated_at text NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  PRIMARY KEY (org_id, slug),
+  CHECK (kind IN ('executable','instruction'))
+);
+
+CREATE INDEX IF NOT EXISTS skills_registry_org_updated_idx ON skills_registry (org_id, updated_at DESC);