@hasna/hooks 0.2.20 → 0.3.0

package/dist/index.js

@@ -28,25 +28,25 @@ __export(exports_profiles, {
   deleteProfile: () => deleteProfile,
   createProfile: () => createProfile
 });
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, readdirSync, rmSync, cpSync } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, readdirSync as readdirSync2, rmSync, cpSync as cpSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 function resolveProfilesDir() {
-  const newDir = join2(homedir2(), ".hasna", "hooks", "profiles");
-  const oldDir = join2(homedir2(), ".hooks", "profiles");
-  if (!existsSync2(newDir) && existsSync2(oldDir)) {
-    mkdirSync2(join2(homedir2(), ".hasna", "hooks"), { recursive: true });
-    cpSync(oldDir, newDir, { recursive: true });
+  const newDir = join4(homedir4(), ".hasna", "hooks", "profiles");
+  const oldDir = join4(homedir4(), ".hooks", "profiles");
+  if (!existsSync4(newDir) && existsSync4(oldDir)) {
+    mkdirSync3(join4(homedir4(), ".hasna", "hooks"), { recursive: true });
+    cpSync2(oldDir, newDir, { recursive: true });
   }
   return newDir;
 }
 function ensureProfilesDir() {
-  if (!existsSync2(PROFILES_DIR)) {
-    mkdirSync2(PROFILES_DIR, { recursive: true });
+  if (!existsSync4(PROFILES_DIR)) {
+    mkdirSync3(PROFILES_DIR, { recursive: true });
   }
 }
 function profilePath(id) {
-  return join2(PROFILES_DIR, `${id}.json`);
+  return join4(PROFILES_DIR, `${id}.json`);
 }
 function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
@@ -75,22 +75,22 @@ function createProfile(input) {
 function getProfile(id) {
   const path = profilePath(id);
   try {
-    if (!existsSync2(path))
+    if (!existsSync4(path))
       return null;
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function listProfiles() {
-  if (!existsSync2(PROFILES_DIR))
+  if (!existsSync4(PROFILES_DIR))
     return [];
   try {
-    const files = readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json"));
+    const files = readdirSync2(PROFILES_DIR).filter((f) => f.endsWith(".json"));
     const profiles = [];
     for (const file of files) {
       try {
-        const content = readFileSync2(join2(PROFILES_DIR, file), "utf-8");
+        const content = readFileSync3(join4(PROFILES_DIR, file), "utf-8");
         profiles.push(JSON.parse(content));
       } catch {}
     }
@@ -113,7 +113,7 @@ function updateProfile(id, data) {
 }
 function deleteProfile(id) {
   const path = profilePath(id);
-  if (!existsSync2(path))
+  if (!existsSync4(path))
     return false;
   try {
     rmSync(path);
@@ -143,7 +143,7 @@ function importProfiles(profiles) {
       continue;
     }
     const path = profilePath(profile.agent_id);
-    if (existsSync2(path)) {
+    if (existsSync4(path)) {
       skipped++;
       continue;
     }
@@ -158,7 +158,670 @@ var init_profiles = __esm(() => {
   PROFILES_DIR = resolveProfilesDir();
 });
 
+// src/db/index.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2, mkdirSync, cpSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/db/schema.ts
+var CREATE_HOOK_EVENTS_TABLE = `
+  CREATE TABLE IF NOT EXISTS hook_events (
+    id           TEXT PRIMARY KEY,
+    timestamp    TEXT NOT NULL,
+    session_id   TEXT NOT NULL,
+    hook_name    TEXT NOT NULL,
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit')),
+    tool_name    TEXT,
+    tool_input   TEXT,
+    result       TEXT CHECK (result IN ('continue', 'block', NULL)),
+    error        TEXT,
+    duration_ms  INTEGER,
+    project_dir  TEXT,
+    metadata     TEXT
+  )
+`;
+var CREATE_INDEXES = [
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_timestamp  ON hook_events (timestamp)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_session_id ON hook_events (session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_hook_name  ON hook_events (hook_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_event_type ON hook_events (event_type)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_errors     ON hook_events (timestamp) WHERE error IS NOT NULL`
+];
+
+// src/db/migrations/001_initial.ts
+function up(db) {
+  db.exec(CREATE_HOOK_EVENTS_TABLE);
+  for (const idx of CREATE_INDEXES) {
+    db.exec(idx);
+  }
+}
+
+// src/db/migrations/002_session_events.ts
+function up2(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("hook_events");
+  if (!row?.sql)
+    return;
+  if (row.sql.includes("SessionStart"))
+    return;
+  db.exec("BEGIN");
+  try {
+    db.exec("ALTER TABLE hook_events RENAME TO hook_events_old");
+    db.exec(CREATE_HOOK_EVENTS_TABLE);
+    db.exec(`INSERT INTO hook_events
+         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       SELECT id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata
+       FROM hook_events_old`);
+    db.exec("DROP TABLE hook_events_old");
+    for (const idx of CREATE_INDEXES) {
+      db.exec(idx);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/db/migrations/003_user_prompt_submit_event.ts
+function up3(db) {
+  const row = db.query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?").get("hook_events");
+  if (!row?.sql)
+    return;
+  if (row.sql.includes("UserPromptSubmit"))
+    return;
+  db.exec("BEGIN");
+  try {
+    db.exec("ALTER TABLE hook_events RENAME TO hook_events_old");
+    db.exec(CREATE_HOOK_EVENTS_TABLE);
+    db.exec(`INSERT INTO hook_events
+         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
+       SELECT id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata
+       FROM hook_events_old`);
+    db.exec("DROP TABLE hook_events_old");
+    for (const idx of CREATE_INDEXES) {
+      db.exec(idx);
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+// src/db/migrations/index.ts
+var MIGRATIONS = [
+  { version: "001_initial", up },
+  { version: "002_session_events", up: up2 },
+  { version: "003_user_prompt_submit_event", up: up3 }
+];
+function ensureMigrationsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version    TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    )
+  `);
+}
+function getApplied(db) {
+  const rows = db.query("SELECT version FROM schema_migrations").all();
+  return new Set(rows.map((r) => r.version));
+}
+function runMigrations(db) {
+  ensureMigrationsTable(db);
+  const applied = getApplied(db);
+  for (const migration of MIGRATIONS) {
+    if (applied.has(migration.version))
+      continue;
+    migration.up(db);
+    db.run("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", [
+      migration.version,
+      new Date().toISOString()
+    ]);
+  }
+}
+
+// src/db/legacy-import.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var META_KEY = "legacy_import_done";
+function ensureMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+}
+function isAlreadyDone(db) {
+  ensureMetaTable(db);
+  const row = db.query("SELECT value FROM _meta WHERE key = ?").get(META_KEY);
+  return row?.value === "1";
+}
+function markDone(db) {
+  db.run("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)", [META_KEY, "1"]);
+}
+function nanoid() {
+  return crypto.randomUUID().replace(/-/g, "").slice(0, 21);
+}
+function importJsonlFile(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync(filePath, "utf-8").split(`
+`).filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, project_dir)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          entry.timestamp ?? new Date().toISOString(),
+          entry.session_id ?? "legacy",
+          "sessionlog",
+          "PostToolUse",
+          entry.tool_name ?? null,
+          entry.tool_input ? String(entry.tool_input).slice(0, 500) : null,
+          null
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function importErrorsLog(db, filePath) {
+  let count = 0;
+  try {
+    const lines = readFileSync(filePath, "utf-8").split(`
+`).filter(Boolean);
+    const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
+    for (const line of lines) {
+      try {
+        const m = line.match(linePattern);
+        if (!m)
+          continue;
+        const [, timestamp, sessionPrefix, , errorMsg] = m;
+        db.run(`INSERT OR IGNORE INTO hook_events
+            (id, timestamp, session_id, hook_name, event_type, error)
+           VALUES (?, ?, ?, ?, ?, ?)`, [
+          nanoid(),
+          timestamp,
+          sessionPrefix ? `legacy-${sessionPrefix}` : "legacy",
+          "errornotify",
+          "PostToolUse",
+          errorMsg.slice(0, 500)
+        ]);
+        count++;
+      } catch {}
+    }
+  } catch {}
+  return count;
+}
+function runLegacyImport(db) {
+  try {
+    if (isAlreadyDone(db))
+      return;
+    let total = 0;
+    const claudeProjectsDir = join(homedir(), ".claude", "projects");
+    if (existsSync(claudeProjectsDir)) {
+      try {
+        const projectDirs = readdirSync(claudeProjectsDir);
+        for (const dir of projectDirs) {
+          const projectDir = join(claudeProjectsDir, dir);
+          try {
+            const files = readdirSync(projectDir);
+            for (const file of files) {
+              if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
+                total += importJsonlFile(db, join(projectDir, file));
+              }
+              if (file === "errors.log") {
+                total += importErrorsLog(db, join(projectDir, file));
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+    markDone(db);
+    if (total > 0) {
+      process.stderr.write(`[hooks] Imported ${total} legacy log entries into SQLite.
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`[hooks] Legacy import failed (non-fatal): ${err}
+`);
+  }
+}
+
+// src/db/retention.ts
+function runRetention(db, days) {
+  const envDays = parseInt(process.env.HOOKS_RETENTION_DAYS ?? "30");
+  const retentionDays = days ?? (isNaN(envDays) || envDays <= 0 ? 30 : envDays);
+  const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+  try {
+    db.run("DELETE FROM hook_events WHERE timestamp < ?", [cutoff]);
+    const changes = db.query("SELECT changes() as changes").get()?.changes ?? 0;
+    return changes;
+  } catch {
+    return 0;
+  }
+}
+
+// src/db/index.ts
+var instance = null;
+function resolveDataDir() {
+  const explicit = process.env.HASNA_HOOKS_DATA_DIR ?? process.env.HOOKS_DATA_DIR;
+  if (explicit)
+    return explicit;
+  const newDir = join2(homedir2(), ".hasna", "hooks");
+  const oldDir = join2(homedir2(), ".hooks");
+  if (!existsSync2(newDir) && existsSync2(oldDir)) {
+    mkdirSync(join2(homedir2(), ".hasna"), { recursive: true });
+    cpSync(oldDir, newDir, { recursive: true });
+  }
+  return newDir;
+}
+function getDbPath() {
+  const explicitDb = process.env.HASNA_HOOKS_DB_PATH ?? process.env.HOOKS_DB_PATH;
+  if (explicitDb)
+    return explicitDb;
+  const dataDir = resolveDataDir();
+  return join2(dataDir, "hooks.db");
+}
+function ensureDir(dbPath) {
+  const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+  if (dir && !existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function getDb() {
+  if (instance)
+    return instance;
+  const dbPath = getDbPath();
+  const isNew = dbPath === ":memory:" || !existsSync2(dbPath);
+  ensureDir(dbPath);
+  instance = new Database(dbPath);
+  instance.exec("PRAGMA journal_mode=WAL");
+  instance.exec("PRAGMA foreign_keys=ON");
+  runMigrations(instance);
+  runRetention(instance);
+  instance.exec(`CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  )`);
+  if (isNew) {
+    runLegacyImport(instance);
+  }
+  return instance;
+}
+
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS = [
+  `CREATE TABLE IF NOT EXISTS hook_events (
+    id           TEXT PRIMARY KEY,
+    timestamp    TEXT NOT NULL,
+    session_id   TEXT NOT NULL,
+    hook_name    TEXT NOT NULL,
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit')),
+    tool_name    TEXT,
+    tool_input   TEXT,
+    result       TEXT CHECK (result IN ('continue', 'block', NULL)),
+    error        TEXT,
+    duration_ms  INTEGER,
+    project_dir  TEXT,
+    metadata     TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_timestamp  ON hook_events (timestamp)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_session_id ON hook_events (session_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_hook_name  ON hook_events (hook_name)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_event_type ON hook_events (event_type)`,
+  `CREATE INDEX IF NOT EXISTS idx_hook_events_errors     ON hook_events (timestamp) WHERE error IS NOT NULL`,
+  `CREATE TABLE IF NOT EXISTS schema_migrations (
+    version    TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS _meta (
+    key   TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TEXT NOT NULL DEFAULT NOW()::text
+  )`,
+  `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
+  `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`
+];
+
+// src/db/remote-storage.ts
+import pg from "pg";
+function translatePlaceholders(sql) {
+  let index = 0;
+  return sql.replace(/\?/g, () => `$${++index}`);
+}
+function normalizeParams(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((value) => value === undefined ? null : value);
+}
+function sslConfigFor(connectionString) {
+  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+}
+
+class PgAdapterAsync {
+  pool;
+  constructor(connectionString) {
+    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) });
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return { changes: result.rowCount ?? 0 };
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params));
+    return result.rows;
+  }
+  async close() {
+    await this.pool.end();
+  }
+}
+
+// src/db/storage-sync.ts
+var STORAGE_TABLES = [
+  "hook_events",
+  "schema_migrations",
+  "_meta",
+  "feedback"
+];
+var HOOKS_STORAGE_TABLES = STORAGE_TABLES;
+var HOOKS_STORAGE_ENV = "HASNA_HOOKS_DATABASE_URL";
+var HOOKS_STORAGE_FALLBACK_ENV = "HOOKS_DATABASE_URL";
+var HOOKS_STORAGE_MODE_ENV = "HASNA_HOOKS_STORAGE_MODE";
+var HOOKS_STORAGE_MODE_FALLBACK_ENV = "HOOKS_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [HOOKS_STORAGE_ENV, HOOKS_STORAGE_FALLBACK_ENV];
+var STORAGE_MODE_ENV = [HOOKS_STORAGE_MODE_ENV, HOOKS_STORAGE_MODE_FALLBACK_ENV];
+var PRIMARY_KEYS = {
+  hook_events: ["id"],
+  schema_migrations: ["version"],
+  _meta: ["key"],
+  feedback: ["id"]
+};
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeStorageMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) ?? null : null;
+}
+function getStorageMode() {
+  const mode = normalizeStorageMode(readEnv(HOOKS_STORAGE_MODE_ENV)) ?? normalizeStorageMode(readEnv(HOOKS_STORAGE_MODE_FALLBACK_ENV));
+  if (mode)
+    return mode;
+  return getStorageDatabaseUrl() ? "hybrid" : "local";
+}
+async function getStoragePg() {
+  const url = getStorageDatabaseUrl();
+  if (!url) {
+    throw new Error("Missing HASNA_HOOKS_DATABASE_URL or HOOKS_DATABASE_URL");
+  }
+  return new PgAdapterAsync(url);
+}
+async function runStorageMigrations(remote) {
+  await remote.run("CREATE EXTENSION IF NOT EXISTS pgcrypto");
+  for (const sql of PG_MIGRATIONS)
+    await remote.run(sql);
+}
+async function storagePush(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pushTable(db, remote, table));
+    }
+    recordSyncMeta(db, "push", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storagePull(options) {
+  const remote = await getStoragePg();
+  const db = getDb();
+  try {
+    await runStorageMigrations(remote);
+    const results = [];
+    for (const table of resolveTables(options?.tables)) {
+      results.push(await pullTable(remote, db, table));
+    }
+    recordSyncMeta(db, "pull", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function storageSync(options) {
+  const pull = await storagePull(options);
+  const push = await storagePush(options);
+  return { pull, push };
+}
+function getSyncMetaAll() {
+  const db = getDb();
+  ensureSyncMetaTable(db);
+  return db.query("SELECT table_name, last_synced_at, direction FROM _hooks_sync_meta ORDER BY table_name, direction").all();
+}
+function getStorageStatus() {
+  const activeEnv = getStorageDatabaseEnv();
+  return {
+    configured: Boolean(activeEnv),
+    mode: getStorageMode(),
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "hooks",
+    tables: STORAGE_TABLES,
+    sync: getSyncMetaAll()
+  };
+}
+function resolveTables(tables) {
+  if (!tables || tables.length === 0)
+    return [...STORAGE_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
+  const requested = tables.map((table) => table.trim()).filter(Boolean);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown hooks sync table(s): ${invalid.join(", ")}`);
+  return requested;
+}
+function parseStorageTables(value) {
+  if (!value)
+    return;
+  return resolveTables(Array.isArray(value) ? value : value.split(","));
+}
+async function pushTable(db, remote, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all();
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const remoteColumns = await getRemoteColumns(remote, table);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, rows, remoteColumns);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function pullTable(remote, db, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    if (!tableExists(db, table))
+      return result;
+    const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`);
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, rows);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function getRemoteColumns(remote, table) {
+  const rows = await remote.all("SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ?", table);
+  return new Map(rows.map((row) => [row.column_name, row.data_type]));
+}
+function filterRemoteColumns(remoteColumns, columns) {
+  if (remoteColumns.size === 0)
+    return columns;
+  return columns.filter((column) => remoteColumns.has(column));
+}
+function filterLocalColumns(db, table, columns) {
+  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all();
+  const allowed = new Set(rows.map((row) => row.name));
+  return columns.filter((column) => allowed.has(column));
+}
+async function upsertPg(remote, table, columns, rows, remoteColumns) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  for (const row of rows) {
+    await remote.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+       ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`, ...columns.map((column) => coerceForPg(row[column], remoteColumns.get(column))));
+  }
+  return rows.length;
+}
+function upsertSqlite(db, table, columns, rows) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = excluded.${quoteIdent(fallbackKey)}`;
+  const statement = db.query(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+     ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}`);
+  const insert = db.transaction((batch) => {
+    for (const row of batch)
+      statement.run(...columns.map((column) => coerceForSqlite(row[column])));
+  });
+  insert(rows);
+  return rows.length;
+}
+function recordSyncMeta(db, direction, results) {
+  ensureSyncMetaTable(db);
+  const now = new Date().toISOString();
+  const statement = db.query(`
+    INSERT INTO _hooks_sync_meta (table_name, last_synced_at, direction)
+    VALUES (?, ?, ?)
+    ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at
+  `);
+  for (const result of results) {
+    if (result.errors.length > 0)
+      continue;
+    statement.run(result.table, now, direction);
+  }
+}
+function ensureSyncMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _hooks_sync_meta (
+      table_name TEXT NOT NULL,
+      last_synced_at TEXT,
+      direction TEXT NOT NULL CHECK(direction IN ('push', 'pull')),
+      PRIMARY KEY (table_name, direction)
+    )
+  `);
+}
+function tableExists(db, table) {
+  const row = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+  return Boolean(row);
+}
+function quoteIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function coerceForPg(value, dataType) {
+  if (value === undefined || value === null)
+    return null;
+  if (dataType === "boolean") {
+    if (typeof value === "boolean")
+      return value;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string")
+      return value === "1" || value.toLowerCase() === "true";
+  }
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return value;
+}
+function coerceForSqlite(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean")
+    return value;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return String(value);
+}
 // src/lib/registry.ts
+var HOOK_EVENTS = [
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "Notification",
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit"
+];
 var CATEGORIES = [
   "Git Safety",
   "Code Quality",
@@ -202,6 +865,16 @@ var HOOKS = [
     matcher: "Write|Edit|NotebookEdit",
     tags: ["git", "snapshot", "rollback", "backup"]
   },
+  {
+    name: "worktree-guard",
+    displayName: "Worktree Guard",
+    description: "Warns on feature work outside managed repos worktrees and blocks commit/push from shared checkouts",
+    version: "0.1.0",
+    category: "Git Safety",
+    event: "PreToolUse",
+    matcher: "Bash|Write|Edit|MultiEdit|NotebookEdit",
+    tags: ["git", "worktree", "repos", "multi-agent", "safety"]
+  },
   {
     name: "checktests",
     displayName: "Check Tests",
@@ -282,6 +955,16 @@ var HOOKS = [
     matcher: "Bash",
     tags: ["npm", "packages", "typosquatting", "supply-chain"]
   },
+  {
+    name: "pre-bash",
+    displayName: "Pre Bash",
+    description: "Codewith Bash gate for staged secrets scans before commit/push and comms rechecks before risky operations",
+    version: "0.1.0",
+    category: "Security",
+    event: "PreToolUse",
+    matcher: "Bash",
+    tags: ["codewith", "bash", "secrets", "gitleaks", "risky-ops"]
+  },
   {
     name: "phonenotify",
     displayName: "Phone Notify",
@@ -392,6 +1075,16 @@ var HOOKS = [
     matcher: "",
     tags: ["prompt", "injection", "security", "validation", "guard"]
   },
+  {
+    name: "prompt-guard",
+    displayName: "Prompt Guard (Codewith)",
+    description: "Codewith UserPromptSubmit guard for obvious pasted prompt-injection and fake policy/freeze instructions",
+    version: "0.1.0",
+    category: "Permissions",
+    event: "UserPromptSubmit",
+    matcher: "",
+    tags: ["codewith", "prompt", "injection", "policy", "freeze"]
+  },
   {
     name: "desktopnotify",
     displayName: "Desktop Notify",
@@ -482,6 +1175,26 @@ var HOOKS = [
     matcher: "",
     tags: ["tasks", "completion", "gate", "quality", "agent-teams"]
   },
+  {
+    name: "session-start",
+    displayName: "Session Start",
+    description: "Codewith SessionStart digest for blockers, announcements, identity registration, and heartbeat context",
+    version: "0.1.0",
+    category: "Agent Teams",
+    event: "SessionStart",
+    matcher: "",
+    tags: ["codewith", "session", "context", "conversations", "heartbeat"]
+  },
+  {
+    name: "stop-sync",
+    displayName: "Stop Sync",
+    description: "Codewith Stop turn-end heartbeat and best-effort task evidence helper",
+    version: "0.1.0",
+    category: "Agent Teams",
+    event: "Stop",
+    matcher: "",
+    tags: ["codewith", "stop", "heartbeat", "todos", "turn-end"]
+  },
   {
     name: "typecheck-gate",
     displayName: "Typecheck Gate",
@@ -535,10 +1248,10 @@ var HOOKS = [
   {
     name: "announce-start",
     displayName: "Announce Start",
-    description: "On session start, auto-registers agent, reads messages, and announces to space",
-    version: "0.1.0",
+    description: "On SessionStart, auto-registers agent, reads messages, and announces to space",
+    version: "0.2.0",
     category: "Agent Teams",
-    event: "Notification",
+    event: "SessionStart",
     matcher: "",
     tags: ["announcement", "start", "register", "messages", "agent-teams"]
   },
@@ -561,6 +1274,36 @@ var HOOKS = [
     event: "Notification",
     matcher: "",
     tags: ["messages", "dm", "context", "inject", "agent-teams"]
+  },
+  {
+    name: "fleet-catchup",
+    displayName: "Fleet Catchup",
+    description: "On SessionStart, injects unread blockers, channel notifications, and the announcements digest into context (deterministic CLI reads, fail-open)",
+    version: "0.1.0",
+    category: "Agent Teams",
+    event: "SessionStart",
+    matcher: "",
+    tags: ["fleet", "catchup", "blockers", "announcements", "context", "agent-teams"]
+  },
+  {
+    name: "agent-rules-version-check",
+    displayName: "Agent Rules Version Check",
+    description: "On SessionStart, compares the rendered hasna:agent-operating-rules sentinel version against configs state and warns on mismatch",
+    version: "0.1.0",
+    category: "Agent Teams",
+    event: "SessionStart",
+    matcher: "",
+    tags: ["fleet", "rules", "version", "sentinel", "configs", "drift", "agent-teams"]
+  },
+  {
+    name: "fleet-blockers-gate",
+    displayName: "Fleet Blockers Gate",
+    description: "Before tool calls, blocks mutating tools while an unread [FREEZE] blocker is active (TTL-cached conversations check, fail-open <500ms)",
+    version: "0.1.0",
+    category: "Agent Teams",
+    event: "PreToolUse",
+    matcher: "",
+    tags: ["fleet", "freeze", "blockers", "gate", "safety", "agent-teams"]
   }
 ];
 function getHooksByCategory(category) {
@@ -574,21 +1317,21 @@ function getHook(name) {
   return HOOKS.find((h) => h.name === name);
 }
 // src/lib/installer.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
 import { fileURLToPath } from "url";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var HOOKS_DIR = existsSync(join(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join(__dirname2, "..", "..", "hooks") : join(__dirname2, "..", "hooks");
+var HOOKS_DIR = existsSync3(join3(__dirname2, "..", "..", "hooks", "hook-gitguard")) ? join3(__dirname2, "..", "..", "hooks") : join3(__dirname2, "..", "hooks");
 function normalizeHookName(name) {
   return name.startsWith("hook-") ? name : `hook-${name}`;
 }
 function shortHookName(name) {
-  return normalizeHookName(name).replace("hook-", "");
+  return name.startsWith("hook-") ? name.slice("hook-".length) : name;
 }
 function removeHookEntriesByName(entries, hookName) {
   return entries.filter((entry) => !entry.hooks?.some((h) => {
-    const match = h.command?.match(/^hooks run (\w+)/);
+    const match = h.command?.match(/^hooks run ([\w-]+)/);
     return match && match[1] === hookName;
   }));
 }
@@ -597,38 +1340,64 @@ var EVENT_MAP = {
     PreToolUse: "PreToolUse",
     PostToolUse: "PostToolUse",
     Stop: "Stop",
-    Notification: "Notification"
+    Notification: "Notification",
+    SessionStart: "SessionStart",
+    SessionEnd: "SessionEnd",
+    UserPromptSubmit: null
   },
   gemini: {
     PreToolUse: "BeforeTool",
     PostToolUse: "AfterTool",
     Stop: "AfterAgent",
-    Notification: "Notification"
+    Notification: "Notification",
+    SessionStart: null,
+    SessionEnd: null,
+    UserPromptSubmit: null
+  },
+  codewith: {
+    PreToolUse: "PreToolUse",
+    PostToolUse: "PostToolUse",
+    Stop: "Stop",
+    Notification: null,
+    SessionStart: "SessionStart",
+    SessionEnd: null,
+    UserPromptSubmit: "UserPromptSubmit"
   }
 };
 function getTargetSettingsDir(target) {
+  if (target === "codewith")
+    return ".codewith";
   if (target === "gemini")
     return ".gemini";
   return ".claude";
 }
-function getSettingsPath(scope = "global", target = "claude") {
+function getSettingsPath(scope = "global", target = "claude", codewithConfigPath) {
+  if (target === "codewith" && codewithConfigPath)
+    return codewithConfigPath;
+  if (target === "codewith" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
+    return process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH;
+  }
   const dir = getTargetSettingsDir(target);
   if (scope === "project") {
-    return join(process.cwd(), dir, "settings.json");
+    return target === "codewith" ? join3(process.cwd(), dir, "config.toml") : join3(process.cwd(), dir, "settings.json");
   }
-  return join(homedir(), dir, "settings.json");
+  return target === "codewith" ? join3(homedir3(), dir, "config.toml") : join3(homedir3(), dir, "settings.json");
 }
 function getHookPath(name) {
-  return join(HOOKS_DIR, normalizeHookName(name));
+  const shortName = shortHookName(name);
+  const direct = join3(HOOKS_DIR, shortName);
+  if (existsSync3(direct))
+    return direct;
+  return join3(HOOKS_DIR, normalizeHookName(shortName));
 }
 function hookExists(name) {
-  return existsSync(getHookPath(name));
+  return existsSync3(getHookPath(name));
 }
 function readSettings(scope = "global", target = "claude") {
   const path = getSettingsPath(scope, target);
   try {
-    if (existsSync(path)) {
-      return JSON.parse(readFileSync(path, "utf-8"));
+    if (existsSync3(path)) {
+      return JSON.parse(readFileSync2(path, "utf-8"));
     }
   } catch (error) {
     console.warn(`[hooks] Failed to read settings at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -638,14 +1407,101 @@ function readSettings(scope = "global", target = "claude") {
 function writeSettings(settings, scope = "global", target = "claude") {
   const path = getSettingsPath(scope, target);
   const dir = dirname(path);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
+  if (!existsSync3(dir)) {
+    mkdirSync2(dir, { recursive: true });
   }
   writeFileSync(path, JSON.stringify(settings, null, 2) + `
 `);
 }
 function getTargetEventName(internalEvent, target) {
-  return EVENT_MAP[target]?.[internalEvent] || internalEvent;
+  return EVENT_MAP[target]?.[internalEvent] ?? null;
+}
+function isEventSupported(internalEvent, target) {
+  return getTargetEventName(internalEvent, target) !== null;
+}
+function tomlString(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function codewithMatcher(matcher) {
+  if (!matcher)
+    return;
+  if (matcher.startsWith("^"))
+    return matcher;
+  if (matcher.includes("|"))
+    return `^(${matcher})$`;
+  return `^${matcher}$`;
+}
+function codewithTimeout(name) {
+  switch (name) {
+    case "session-start":
+      return 8;
+    case "pre-bash":
+      return 20;
+    case "prompt-guard":
+      return 3;
+    case "worktree-guard":
+    case "stop-sync":
+      return 5;
+    default:
+      return 10;
+  }
+}
+function codewithStatusMessage(name) {
+  switch (name) {
+    case "session-start":
+      return "Checking Hasna session context";
+    case "pre-bash":
+      return "Checking Bash safety";
+    case "prompt-guard":
+      return "Checking prompt safety";
+    case "worktree-guard":
+      return "Checking worktree safety";
+    case "stop-sync":
+      return "Syncing turn-end heartbeat";
+    default:
+      return `Running ${name}`;
+  }
+}
+function buildCodewithTomlFragment(name, profile) {
+  const shortName = shortHookName(name);
+  const meta = getHook(shortName);
+  if (!meta)
+    throw new Error(`Hook '${shortName}' not found`);
+  const eventKey = getTargetEventName(meta.event, "codewith");
+  if (!eventKey) {
+    throw new Error(`Hook '${shortName}' uses event '${meta.event}', which is not supported by the Codewith target`);
+  }
+  const command = profile ? `hooks run ${shortName} --profile ${profile}` : `hooks run ${shortName}`;
+  const matcher = codewithMatcher(meta.matcher);
+  const lines = [
+    `[[hooks.${eventKey}]]`
+  ];
+  if (matcher)
+    lines.push(`matcher = ${tomlString(matcher)}`);
+  lines.push("", `[[hooks.${eventKey}.hooks]]`, `type = "command"`, `command = ${tomlString(command)}`, `timeout = ${codewithTimeout(shortName)}`, `statusMessage = ${tomlString(codewithStatusMessage(shortName))}`);
+  return `${lines.join(`
+`)}
+`;
+}
+function readCodewithConfig(scope, configPath) {
+  const path = getSettingsPath(scope, "codewith", configPath);
+  try {
+    return existsSync3(path) ? readFileSync2(path, "utf-8") : "";
+  } catch {
+    return "";
+  }
+}
+function appendCodewithFragment(fragment, scope, configPath) {
+  const path = getSettingsPath(scope, "codewith", configPath);
+  const dir = dirname(path);
+  if (!existsSync3(dir))
+    mkdirSync2(dir, { recursive: true });
+  const existing = existsSync3(path) ? readFileSync2(path, "utf-8") : "";
+  const sep = existing.trim() ? `
+
+` : "";
+  writeFileSync(path, `${existing.replace(/\s*$/, "")}${sep}${fragment}`);
+  return path;
 }
 function detectConflict(name, scope, target) {
   const meta = getHook(name);
@@ -666,11 +1522,60 @@ function detectConflict(name, scope, target) {
   }
   return;
 }
-function installForTarget(name, scope, overwrite, target, profile) {
+function installForTarget(name, scope, overwrite, target, profile, codewithMode = "fragment", codewithConfigPath) {
   const shortName = shortHookName(name);
   if (!hookExists(shortName)) {
     return { hook: shortName, success: false, error: `Hook '${shortName}' not found`, target };
   }
+  if (target === "codewith") {
+    try {
+      const fragment = buildCodewithTomlFragment(shortName, profile);
+      if (codewithMode !== "write") {
+        return {
+          hook: shortName,
+          success: true,
+          scope,
+          target,
+          fragment,
+          applied: false,
+          note: "Codewith install is fragment-only by default; open-configs should own applying this TOML."
+        };
+      }
+      if (!codewithConfigPath) {
+        return {
+          hook: shortName,
+          success: false,
+          error: "Direct Codewith writes require an explicit --codewith-config path; refusing to write default ~/.codewith/config.toml.",
+          scope,
+          target,
+          fragment,
+          applied: false
+        };
+      }
+      const existing = readCodewithConfig(scope, codewithConfigPath);
+      if (!overwrite && new RegExp(`command\\s*=\\s*["']hooks run ${shortName}(?:\\s|["'])`).test(existing)) {
+        return { hook: shortName, success: false, error: "Already installed. Use --overwrite to append another fragment.", scope, target };
+      }
+      const path = appendCodewithFragment(fragment, scope, codewithConfigPath);
+      return {
+        hook: shortName,
+        success: true,
+        scope,
+        target,
+        fragment,
+        applied: true,
+        configPath: path,
+        note: "Direct Codewith config write was explicitly requested; prefer open-configs for managed machines."
+      };
+    } catch (error) {
+      return {
+        hook: shortName,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        target
+      };
+    }
+  }
   const registered = getRegisteredHooksForTarget(scope, target);
   if (registered.includes(shortName) && !overwrite) {
     return { hook: shortName, success: false, error: "Already installed. Use --overwrite to replace.", scope, target };
@@ -689,25 +1594,63 @@ function installForTarget(name, scope, overwrite, target, profile) {
   }
 }
 function installHook(name, options = {}) {
-  const { scope = "global", overwrite = false, target = "claude", profile } = options;
+  const { scope = "global", overwrite = false, target = "claude", profile, codewithMode = "fragment", codewithConfigPath } = options;
   if (target === "all") {
+    const shortName = shortHookName(name);
+    const meta = getHook(shortName);
+    if (meta) {
+      const unsupportedTargets = ["claude", "gemini", "codewith"].filter((agentTarget) => !isEventSupported(meta.event, agentTarget));
+      if (unsupportedTargets.length > 0) {
+        return {
+          hook: shortName,
+          success: false,
+          error: `Event '${meta.event}' is not supported by target(s): ${unsupportedTargets.join(", ")}`,
+          target: "all"
+        };
+      }
+    }
     const claudeResult = installForTarget(name, scope, overwrite, "claude", profile);
-    installForTarget(name, scope, overwrite, "gemini", profile);
+    if (!claudeResult.success) {
+      return {
+        ...claudeResult,
+        error: `Failed for target 'claude': ${claudeResult.error}`,
+        target: "all"
+      };
+    }
+    const geminiResult = installForTarget(name, scope, overwrite, "gemini", profile);
+    if (!geminiResult.success) {
+      return {
+        ...geminiResult,
+        error: `Failed for target 'gemini': ${geminiResult.error}`,
+        target: "all"
+      };
+    }
+    const codewithResult = installForTarget(name, scope, overwrite, "codewith", profile, codewithMode, codewithConfigPath);
+    if (!codewithResult.success) {
+      return {
+        ...codewithResult,
+        error: `Failed for target 'codewith': ${codewithResult.error}`,
+        target: "all"
+      };
+    }
     return { ...claudeResult, target: "all" };
   }
-  return installForTarget(name, scope, overwrite, target, profile);
+  return installForTarget(name, scope, overwrite, target, profile, codewithMode, codewithConfigPath);
 }
 function registerHook(name, scope = "global", target = "claude", profile) {
   const meta = getHook(name);
   if (!meta)
     return;
+  const eventKey = getTargetEventName(meta.event, target);
+  if (eventKey === null) {
+    throw new Error(`Event '${meta.event}' is not supported by target '${target}'`);
+  }
   const settings = readSettings(scope, target);
   if (!settings.hooks)
     settings.hooks = {};
-  const eventKey = getTargetEventName(meta.event, target);
+  removeHookFromAllEvents(settings, name);
   if (!settings.hooks[eventKey])
     settings.hooks[eventKey] = [];
-  settings.hooks[eventKey] = removeHookEntriesByName(settings.hooks[eventKey], name);
   const hookCommand = profile ? `hooks run ${name} --profile ${profile}` : `hooks run ${name}`;
   const entry = {
     hooks: [{ type: "command", command: hookCommand }]
@@ -718,6 +1661,16 @@ function registerHook(name, scope = "global", target = "claude", profile) {
   settings.hooks[eventKey].push(entry);
   writeSettings(settings, scope, target);
 }
+function removeHookFromAllEvents(settings, name) {
+  if (!settings.hooks)
+    return;
+  for (const key of Object.keys(settings.hooks)) {
+    settings.hooks[key] = removeHookEntriesByName(settings.hooks[key], name);
+    if (settings.hooks[key].length === 0) {
+      delete settings.hooks[key];
+    }
+  }
+}
 function unregisterHook(name, scope = "global", target = "claude") {
   const meta = getHook(name);
   if (!meta)
@@ -725,13 +1678,7 @@ function unregisterHook(name, scope = "global", target = "claude") {
   const settings = readSettings(scope, target);
   if (!settings.hooks)
     return;
-  const eventKey = getTargetEventName(meta.event, target);
-  if (!settings.hooks[eventKey])
-    return;
-  settings.hooks[eventKey] = removeHookEntriesByName(settings.hooks[eventKey], name);
-  if (settings.hooks[eventKey].length === 0) {
-    delete settings.hooks[eventKey];
-  }
+  removeHookFromAllEvents(settings, name);
   if (Object.keys(settings.hooks).length === 0) {
     delete settings.hooks;
   }
@@ -741,6 +1688,16 @@ function installHooks(names, options = {}) {
   return names.map((name) => installHook(name, options));
 }
 function getRegisteredHooksForTarget(scope = "global", target = "claude") {
+  if (target === "codewith") {
+    const config = readCodewithConfig(scope);
+    const registered2 = [];
+    const re = /command\s*=\s*["']hooks run ([\w-]+)(?:\s+--profile\s+[\w-]+)?["']/g;
+    let match;
+    while (match = re.exec(config)) {
+      registered2.push(match[1]);
+    }
+    return [...new Set(registered2)];
+  }
   const settings = readSettings(scope, target);
   if (!settings.hooks)
     return [];
@@ -748,8 +1705,8 @@ function getRegisteredHooksForTarget(scope = "global", target = "claude") {
   for (const eventKey of Object.keys(settings.hooks)) {
     for (const entry of settings.hooks[eventKey]) {
       for (const hook of entry.hooks || []) {
-        const newMatch = hook.command?.match(/^hooks run (\w+)(?:\s+--profile\s+\w+)?$/);
-        const oldMatch = hook.command?.match(/^hook-(\w+)$/);
+        const newMatch = hook.command?.match(/^hooks run ([\w-]+)(?:\s+--profile\s+[\w-]+)?$/);
+        const oldMatch = hook.command?.match(/^hook-([\w-]+)$/);
         const match = newMatch || oldMatch;
         if (match) {
           registered.push(match[1]);
@@ -770,6 +1727,9 @@ function removeHook(name, scope = "global", target = "claude") {
     const geminiRemoved = removeHookForTarget(shortName, scope, "gemini");
     return claudeRemoved || geminiRemoved;
   }
+  if (target === "codewith") {
+    return false;
+  }
   return removeHookForTarget(shortName, scope, target);
 }
 function removeHookForTarget(name, scope, target) {
@@ -782,8 +1742,8 @@ function removeHookForTarget(name, scope, target) {
 }
 // src/index.ts
 init_profiles();
-import { join as join3 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+import { existsSync as existsSync5 } from "fs";
 function installHookForProject(name, options = {}) {
   return installHook(name, { ...options, scope: "project" });
 }
@@ -801,8 +1761,8 @@ async function runHook(name, input, options = {}) {
   if (!meta)
     throw new Error(`Hook '${name}' not found`);
   const hookDir = getHookPath(name);
-  const hookScript = join3(hookDir, "src", "hook.ts");
-  if (!existsSync3(hookScript))
+  const hookScript = join5(hookDir, "src", "hook.ts");
+  if (!existsSync5(hookScript))
     throw new Error(`Hook script not found: ${hookScript}`);
   let hookInput = { ...input };
   if (options.profile) {
@@ -839,18 +1799,32 @@ async function runHook(name, input, options = {}) {
 export {
   updateProfile,
   touchProfile,
+  storageSync,
+  storagePush,
+  storagePull,
   searchHooks,
+  runStorageMigrations,
   runHook,
+  resolveTables,
   removeProjectHook,
   removeHook,
+  parseStorageTables,
   listProjectHooks,
   listProfiles,
+  isEventSupported,
   installHooksForProject,
   installHooks,
   installHookForProject,
   installHook,
   importProfiles,
   hookExists,
+  getSyncMetaAll,
+  getStorageStatus,
+  getStoragePg,
+  getStorageMode,
+  getStorageDatabaseUrl,
+  getStorageDatabaseEnvName,
+  getStorageDatabaseEnv,
   getSettingsPath,
   getRegisteredHooksForTarget,
   getRegisteredHooks,
@@ -863,6 +1837,16 @@ export {
   exportProfiles,
   deleteProfile,
   createProfile,
+  buildCodewithTomlFragment,
+  STORAGE_TABLES,
+  STORAGE_MODE_ENV,
+  STORAGE_DATABASE_ENV,
+  HOOK_EVENTS,
+  HOOKS_STORAGE_TABLES,
+  HOOKS_STORAGE_MODE_FALLBACK_ENV,
+  HOOKS_STORAGE_MODE_ENV,
+  HOOKS_STORAGE_FALLBACK_ENV,
+  HOOKS_STORAGE_ENV,
   HOOKS,
   CATEGORIES
 };