hotsheet 0.2.2 → 0.2.3

package/dist/cli.js

@@ -9,88 +9,32 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/gitignore.ts
-var gitignore_exports = {};
-__export(gitignore_exports, {
-  addHotsheetToGitignore: () => addHotsheetToGitignore,
-  ensureGitignore: () => ensureGitignore,
-  getGitRoot: () => getGitRoot,
-  isGitRepo: () => isGitRepo,
-  isHotsheetGitignored: () => isHotsheetGitignored
-});
-import { execSync } from "child_process";
-import { appendFileSync, existsSync, readFileSync } from "fs";
-import { join as join2 } from "path";
-function isHotsheetGitignored(repoRoot) {
-  try {
-    execSync("git check-ignore -q .hotsheet", { cwd: repoRoot, stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isGitRepo(dir) {
-  try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd: dir, stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getGitRoot(dir) {
-  try {
-    return execSync("git rev-parse --show-toplevel", { cwd: dir, encoding: "utf-8" }).trim();
-  } catch {
-    return null;
-  }
-}
-function addHotsheetToGitignore(repoRoot) {
-  const gitignorePath = join2(repoRoot, ".gitignore");
-  if (existsSync(gitignorePath)) {
-    const content = readFileSync(gitignorePath, "utf-8");
-    if (content.includes(".hotsheet")) return;
-    const prefix = content.endsWith("\n") ? "" : "\n";
-    appendFileSync(gitignorePath, `${prefix}.hotsheet/
-`);
-  } else {
-    appendFileSync(gitignorePath, ".hotsheet/\n");
-  }
-}
-function ensureGitignore(cwd) {
-  if (!isGitRepo(cwd)) return;
-  const gitRoot = getGitRoot(cwd);
-  if (gitRoot === null) return;
-  if (!isHotsheetGitignored(gitRoot)) {
-    addHotsheetToGitignore(gitRoot);
-    console.log("  Added .hotsheet/ to .gitignore");
-  }
-}
-var init_gitignore = __esm({
-  "src/gitignore.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli.ts
-import { mkdirSync as mkdirSync4 } from "fs";
-import { tmpdir } from "os";
-import { join as join7, resolve } from "path";
-
-// src/cleanup.ts
-import { rmSync as rmSync2 } from "fs";
-
 // src/db/connection.ts
+var connection_exports = {};
+__export(connection_exports, {
+  adoptDb: () => adoptDb,
+  closeDb: () => closeDb,
+  getDb: () => getDb,
+  setDataDir: () => setDataDir
+});
 import { PGlite } from "@electric-sql/pglite";
 import { mkdirSync, rmSync } from "fs";
 import { join } from "path";
-var db = null;
-var currentDbPath = null;
 function setDataDir(dataDir2) {
   const dbDir = join(dataDir2, "db");
   mkdirSync(dbDir, { recursive: true });
   mkdirSync(join(dataDir2, "attachments"), { recursive: true });
   currentDbPath = dbDir;
 }
+async function closeDb() {
+  if (db) {
+    await db.close();
+    db = null;
+  }
+}
+function adoptDb(instance) {
+  db = instance;
+}
 async function getDb() {
   if (db !== null) return db;
   if (currentDbPath === null) throw new Error("Data directory not set. Call setDataDir() first.");
@@ -166,8 +110,318 @@ async function initSchema(db2) {
   `).catch(() => {
   });
 }
+var db, currentDbPath;
+var init_connection = __esm({
+  "src/db/connection.ts"() {
+    "use strict";
+    db = null;
+    currentDbPath = null;
+  }
+});
+
+// src/file-settings.ts
+var file_settings_exports = {};
+__export(file_settings_exports, {
+  getBackupDir: () => getBackupDir,
+  readFileSettings: () => readFileSettings,
+  writeFileSettings: () => writeFileSettings
+});
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function settingsPath(dataDir2) {
+  return join2(dataDir2, "settings.json");
+}
+function readFileSettings(dataDir2) {
+  const path = settingsPath(dataDir2);
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeFileSettings(dataDir2, updates) {
+  const current = readFileSettings(dataDir2);
+  const merged = { ...current, ...updates };
+  writeFileSync(settingsPath(dataDir2), JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  return merged;
+}
+function getBackupDir(dataDir2) {
+  const settings = readFileSettings(dataDir2);
+  return settings.backupDir || join2(dataDir2, "backups");
+}
+var init_file_settings = __esm({
+  "src/file-settings.ts"() {
+    "use strict";
+  }
+});
+
+// src/gitignore.ts
+var gitignore_exports = {};
+__export(gitignore_exports, {
+  addHotsheetToGitignore: () => addHotsheetToGitignore,
+  ensureGitignore: () => ensureGitignore,
+  getGitRoot: () => getGitRoot,
+  isGitRepo: () => isGitRepo,
+  isHotsheetGitignored: () => isHotsheetGitignored
+});
+import { execSync } from "child_process";
+import { appendFileSync, existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+function isHotsheetGitignored(repoRoot) {
+  try {
+    execSync("git check-ignore -q .hotsheet", { cwd: repoRoot, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGitRepo(dir) {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd: dir, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitRoot(dir) {
+  try {
+    return execSync("git rev-parse --show-toplevel", { cwd: dir, encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function addHotsheetToGitignore(repoRoot) {
+  const gitignorePath = join5(repoRoot, ".gitignore");
+  if (existsSync4(gitignorePath)) {
+    const content = readFileSync4(gitignorePath, "utf-8");
+    if (content.includes(".hotsheet")) return;
+    const prefix = content.endsWith("\n") ? "" : "\n";
+    appendFileSync(gitignorePath, `${prefix}.hotsheet/
+`);
+  } else {
+    appendFileSync(gitignorePath, ".hotsheet/\n");
+  }
+}
+function ensureGitignore(cwd) {
+  if (!isGitRepo(cwd)) return;
+  const gitRoot = getGitRoot(cwd);
+  if (gitRoot === null) return;
+  if (!isHotsheetGitignored(gitRoot)) {
+    addHotsheetToGitignore(gitRoot);
+    console.log("  Added .hotsheet/ to .gitignore");
+  }
+}
+var init_gitignore = __esm({
+  "src/gitignore.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli.ts
+import { mkdirSync as mkdirSync6 } from "fs";
+import { tmpdir } from "os";
+import { join as join11, resolve } from "path";
+
+// src/backup.ts
+init_connection();
+init_file_settings();
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { PGlite as PGlite2 } from "@electric-sql/pglite";
+var TIERS = {
+  "5min": { intervalMs: 5 * 60 * 1e3, maxAge: 60 * 60 * 1e3, maxCount: 12 },
+  "hourly": { intervalMs: 60 * 60 * 1e3, maxAge: 12 * 60 * 60 * 1e3, maxCount: 12 },
+  "daily": { intervalMs: 24 * 60 * 60 * 1e3, maxAge: 7 * 24 * 60 * 60 * 1e3, maxCount: 7 }
+};
+var backupInProgress = false;
+var previewDb = null;
+var currentDataDir = null;
+function backupsDir(dataDir2) {
+  return getBackupDir(dataDir2);
+}
+function tierDir(dataDir2, tier) {
+  return join3(backupsDir(dataDir2), tier);
+}
+function formatTimestamp(date) {
+  return date.toISOString().replace(/:/g, "-").replace(/\.\d+Z$/, "Z");
+}
+function parseTimestamp(filename) {
+  const match = filename.match(/^backup-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})Z\.tar\.gz$/);
+  if (!match) return null;
+  const iso = `${match[1]}T${match[2]}:${match[3]}:${match[4]}Z`;
+  const d = new Date(iso);
+  return isNaN(d.getTime()) ? null : d;
+}
+async function createBackup(dataDir2, tier) {
+  if (backupInProgress) return null;
+  backupInProgress = true;
+  try {
+    const db2 = await getDb();
+    const dir = tierDir(dataDir2, tier);
+    mkdirSync2(dir, { recursive: true });
+    const blob = await db2.dumpDataDir("gzip");
+    const buffer = Buffer.from(await blob.arrayBuffer());
+    const now = /* @__PURE__ */ new Date();
+    const filename = `backup-${formatTimestamp(now)}.tar.gz`;
+    const filePath = join3(dir, filename);
+    writeFileSync2(filePath, buffer);
+    let ticketCount = 0;
+    try {
+      const result = await db2.query(`SELECT COUNT(*) as count FROM tickets WHERE status != 'deleted'`);
+      ticketCount = parseInt(result.rows[0]?.count || "0", 10);
+    } catch {
+    }
+    const info = {
+      tier,
+      filename,
+      createdAt: now.toISOString(),
+      ticketCount,
+      sizeBytes: buffer.length
+    };
+    pruneBackups(dataDir2, tier);
+    return info;
+  } catch (err) {
+    console.error(`Backup failed (${tier}):`, err);
+    return null;
+  } finally {
+    backupInProgress = false;
+  }
+}
+function pruneBackups(dataDir2, tier) {
+  const dir = tierDir(dataDir2, tier);
+  if (!existsSync2(dir)) return;
+  const config = TIERS[tier];
+  const cutoff = Date.now() - config.maxAge;
+  const files = readdirSync(dir).filter((f) => f.endsWith(".tar.gz")).map((f) => ({ filename: f, date: parseTimestamp(f) })).filter((f) => f.date !== null).sort((a, b) => b.date.getTime() - a.date.getTime());
+  for (let i = 0; i < files.length; i++) {
+    if (i >= config.maxCount || files[i].date.getTime() < cutoff) {
+      try {
+        rmSync2(join3(dir, files[i].filename), { force: true });
+      } catch {
+      }
+    }
+  }
+}
+function listBackups(dataDir2) {
+  const backups = [];
+  for (const tier of Object.keys(TIERS)) {
+    const dir = tierDir(dataDir2, tier);
+    if (!existsSync2(dir)) continue;
+    for (const filename of readdirSync(dir)) {
+      if (!filename.endsWith(".tar.gz")) continue;
+      const date = parseTimestamp(filename);
+      if (!date) continue;
+      let sizeBytes = 0;
+      try {
+        sizeBytes = statSync(join3(dir, filename)).size;
+      } catch {
+      }
+      backups.push({
+        tier,
+        filename,
+        createdAt: date.toISOString(),
+        ticketCount: -1,
+        // Unknown without opening the backup
+        sizeBytes
+      });
+    }
+  }
+  return backups.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+async function loadBackupForPreview(dataDir2, tier, filename) {
+  await cleanupPreview();
+  const filePath = join3(tierDir(dataDir2, tier), filename);
+  if (!existsSync2(filePath)) throw new Error("Backup file not found");
+  const buffer = readFileSync2(filePath);
+  const blob = new Blob([buffer]);
+  const previewDir = join3(backupsDir(dataDir2), "_preview");
+  mkdirSync2(previewDir, { recursive: true });
+  previewDb = new PGlite2(previewDir, { loadDataDir: blob });
+  await previewDb.waitReady;
+  const tickets = await previewDb.query(
+    `SELECT * FROM tickets WHERE status != 'deleted' ORDER BY created_at DESC`
+  );
+  const statsResult = await previewDb.query(`
+    SELECT
+      COUNT(*) FILTER (WHERE status != 'deleted') as total,
+      COUNT(*) FILTER (WHERE status IN ('not_started', 'started')) as open,
+      COUNT(*) FILTER (WHERE up_next = true AND status != 'deleted') as up_next
+    FROM tickets
+  `);
+  const row = statsResult.rows[0];
+  return {
+    tickets: tickets.rows,
+    stats: {
+      total: parseInt(row?.total || "0", 10),
+      open: parseInt(row?.open || "0", 10),
+      upNext: parseInt(row?.up_next || "0", 10)
+    }
+  };
+}
+async function cleanupPreview() {
+  if (previewDb) {
+    try {
+      await previewDb.close();
+    } catch {
+    }
+    previewDb = null;
+  }
+  if (currentDataDir) {
+    const previewDir = join3(backupsDir(currentDataDir), "_preview");
+    if (existsSync2(previewDir)) {
+      rmSync2(previewDir, { recursive: true, force: true });
+    }
+  }
+}
+async function restoreBackup(dataDir2, tier, filename) {
+  await cleanupPreview();
+  const filePath = join3(tierDir(dataDir2, tier), filename);
+  if (!existsSync2(filePath)) throw new Error("Backup file not found");
+  await createBackup(dataDir2, "5min");
+  const buffer = readFileSync2(filePath);
+  const blob = new Blob([buffer]);
+  await closeDb();
+  const dbDir = join3(dataDir2, "db");
+  rmSync2(dbDir, { recursive: true, force: true });
+  setDataDir(dataDir2);
+  const { getDb: reinitDb } = await Promise.resolve().then(() => (init_connection(), connection_exports));
+  const PGliteClass = (await import("@electric-sql/pglite")).PGlite;
+  const newDb = new PGliteClass(dbDir, { loadDataDir: blob });
+  await newDb.waitReady;
+  const { adoptDb: adoptDb2 } = await Promise.resolve().then(() => (init_connection(), connection_exports));
+  adoptDb2(newDb);
+}
+var fiveMinTimer = null;
+function scheduleFiveMinBackup(dataDir2) {
+  if (fiveMinTimer) clearTimeout(fiveMinTimer);
+  fiveMinTimer = setTimeout(() => {
+    void createBackup(dataDir2, "5min").then(() => scheduleFiveMinBackup(dataDir2));
+  }, TIERS["5min"].intervalMs);
+}
+async function triggerManualBackup(dataDir2) {
+  const result = await createBackup(dataDir2, "5min");
+  if (result) scheduleFiveMinBackup(dataDir2);
+  return result;
+}
+function initBackupScheduler(dataDir2) {
+  currentDataDir = dataDir2;
+  const previewDir = join3(backupsDir(dataDir2), "_preview");
+  if (existsSync2(previewDir)) {
+    rmSync2(previewDir, { recursive: true, force: true });
+  }
+  setTimeout(() => {
+    void createBackup(dataDir2, "5min").then(() => scheduleFiveMinBackup(dataDir2));
+  }, 1e4);
+  setInterval(() => void createBackup(dataDir2, "hourly"), TIERS["hourly"].intervalMs);
+  setInterval(() => void createBackup(dataDir2, "daily"), TIERS["daily"].intervalMs);
+}
+
+// src/cleanup.ts
+import { rmSync as rmSync3 } from "fs";
 
 // src/db/queries.ts
+init_connection();
 function parseNotes(raw2) {
   if (!raw2 || raw2 === "") return [];
   try {
@@ -203,6 +457,10 @@ async function createTicket(title, defaults) {
     cols.push("up_next");
     vals.push(defaults.up_next);
   }
+  if (defaults?.details !== void 0 && defaults.details !== "") {
+    cols.push("details");
+    vals.push(defaults.details);
+  }
   const placeholders = vals.map((_, i) => `$${i + 1}`).join(", ");
   const result = await db2.query(
     `INSERT INTO tickets (${cols.join(", ")}) VALUES (${placeholders}) RETURNING *`,
@@ -461,7 +719,7 @@ async function cleanupAttachments() {
       const attachments = await getAttachments(ticket.id);
       for (const att of attachments) {
         try {
-          rmSync2(att.stored_path, { force: true });
+          rmSync3(att.stored_path, { force: true });
         } catch {
         }
       }
@@ -476,7 +734,59 @@ async function cleanupAttachments() {
   }
 }
 
+// src/cli.ts
+init_connection();
+
+// src/lock.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+var lockPath = null;
+function acquireLock(dataDir2) {
+  lockPath = join4(dataDir2, "hotsheet.lock");
+  if (existsSync3(lockPath)) {
+    try {
+      const contents = JSON.parse(readFileSync3(lockPath, "utf-8"));
+      const pid = contents.pid;
+      try {
+        process.kill(pid, 0);
+        console.error(`
+  Error: Another Hot Sheet instance (PID ${pid}) is already using this data directory.`);
+        console.error(`  Directory: ${dataDir2}`);
+        console.error(`  Stop that instance first, or use --data-dir to point to a different location.
+`);
+        process.exit(1);
+      } catch {
+        console.log(`  Removing stale lock from PID ${pid}`);
+        rmSync4(lockPath, { force: true });
+      }
+    } catch {
+      rmSync4(lockPath, { force: true });
+    }
+  }
+  writeFileSync3(lockPath, JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  const cleanup = () => releaseLock();
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+function releaseLock() {
+  if (lockPath) {
+    try {
+      rmSync4(lockPath, { force: true });
+    } catch {
+    }
+    lockPath = null;
+  }
+}
+
 // src/demo.ts
+init_connection();
 var DEMO_SCENARIOS = [
   { id: 1, label: "Main UI \u2014 all tickets with detail panel" },
   { id: 2, label: "Quick entry \u2014 bullet-list ticket creation" },
@@ -1246,19 +1556,19 @@ init_gitignore();
 // src/server.ts
 import { serve } from "@hono/node-server";
 import { exec } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { Hono as Hono3 } from "hono";
-import { dirname, join as join5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
+import { Hono as Hono4 } from "hono";
+import { dirname, join as join9 } from "path";
 import { fileURLToPath } from "url";
 
 // src/routes/api.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, rmSync as rmSync5 } from "fs";
 import { Hono } from "hono";
-import { basename, extname, join as join4, relative } from "path";
+import { basename, extname, join as join8, relative as relative2 } from "path";
 
-// src/sync/markdown.ts
-import { writeFileSync } from "fs";
-import { join as join3 } from "path";
+// src/skills.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6, relative } from "path";
 
 // src/types.ts
 var CATEGORY_DESCRIPTIONS = {
@@ -1270,7 +1580,251 @@ var CATEGORY_DESCRIPTIONS = {
   investigation: "Items requiring research or analysis"
 };
 
+// src/skills.ts
+var SKILL_VERSION = 1;
+var skillPort;
+var skillDataDir;
+function initSkills(port2, dataDir2) {
+  skillPort = port2;
+  skillDataDir = dataDir2;
+}
+var TICKET_SKILLS = [
+  { name: "hs-bug", category: "bug", label: "bug" },
+  { name: "hs-feature", category: "feature", label: "feature" },
+  { name: "hs-task", category: "task", label: "task" },
+  { name: "hs-issue", category: "issue", label: "issue" },
+  { name: "hs-investigation", category: "investigation", label: "investigation" },
+  { name: "hs-req-change", category: "requirement_change", label: "requirement change" }
+];
+function versionHeader() {
+  return `<!-- hotsheet-skill-version: ${SKILL_VERSION} port: ${skillPort} -->`;
+}
+function parseVersionHeader(content) {
+  const match = content.match(/<!-- hotsheet-skill-version: (\d+) port: (\d+) -->/);
+  if (!match) return null;
+  return { version: parseInt(match[1], 10), port: parseInt(match[2], 10) };
+}
+function updateFile(path, content) {
+  if (existsSync5(path)) {
+    const existing = readFileSync5(path, "utf-8");
+    const header = parseVersionHeader(existing);
+    if (header && header.version >= SKILL_VERSION && header.port === skillPort) {
+      return false;
+    }
+  }
+  writeFileSync4(path, content, "utf-8");
+  return true;
+}
+function ticketSkillBody(skill) {
+  const desc = CATEGORY_DESCRIPTIONS[skill.category];
+  return [
+    `Create a new Hot Sheet **${skill.label}** ticket. ${desc}.`,
+    "",
+    "**Parsing the input:**",
+    '- If the input starts with "next", "up next", or "do next" (case-insensitive), set `up_next` to `true` and use the remaining text as the title',
+    "- Otherwise, use the entire input as the title",
+    "",
+    "**Create the ticket** by running:",
+    "```bash",
+    `curl -s -X POST http://localhost:${skillPort}/api/tickets \\`,
+    '  -H "Content-Type: application/json" \\',
+    `  -d '{"title": "<TITLE>", "defaults": {"category": "${skill.category}", "up_next": <true|false>}}'`,
+    "```",
+    "",
+    "Report the created ticket number and title to the user."
+  ].join("\n");
+}
+function mainSkillBody() {
+  const worklistRel = relative(process.cwd(), join6(skillDataDir, "worklist.md"));
+  return [
+    `Read \`${worklistRel}\` and work through the tickets in priority order.`,
+    "",
+    "For each ticket:",
+    "1. Read the ticket details carefully",
+    "2. Implement the work described",
+    "3. When complete, mark it done via the Hot Sheet UI",
+    "",
+    "Work through them in order of priority, where reasonable."
+  ].join("\n");
+}
+var HOTSHEET_ALLOW_PATTERNS = [
+  "Bash(curl * http://localhost:417*/api/*)",
+  "Bash(curl * http://localhost:418*/api/*)"
+];
+var HOTSHEET_CURL_RE = /^Bash\(curl \* http:\/\/localhost:\d+\/api\/\*\)$|^Bash\(curl \* http:\/\/localhost:41[78]\*\/api\/\*\)$/;
+function ensureClaudePermissions(cwd) {
+  if (skillPort < 4170 || skillPort > 4189) return false;
+  const settingsPath2 = join6(cwd, ".claude", "settings.json");
+  let settings = {};
+  if (existsSync5(settingsPath2)) {
+    try {
+      settings = JSON.parse(readFileSync5(settingsPath2, "utf-8"));
+    } catch {
+    }
+  }
+  if (!settings.permissions) settings.permissions = {};
+  if (!settings.permissions.allow) settings.permissions.allow = [];
+  const allow = settings.permissions.allow;
+  if (HOTSHEET_ALLOW_PATTERNS.every((p) => allow.includes(p))) return false;
+  settings.permissions.allow = allow.filter((p) => !HOTSHEET_CURL_RE.test(p));
+  settings.permissions.allow.push(...HOTSHEET_ALLOW_PATTERNS);
+  writeFileSync4(settingsPath2, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  return true;
+}
+function ensureClaudeSkills(cwd) {
+  let updated = false;
+  const skillsDir = join6(cwd, ".claude", "skills");
+  if (ensureClaudePermissions(cwd)) updated = true;
+  const mainDir = join6(skillsDir, "hotsheet");
+  mkdirSync3(mainDir, { recursive: true });
+  const mainContent = [
+    "---",
+    "name: hotsheet",
+    "description: Read the Hot Sheet worklist and work through the current priority items",
+    "allowed-tools: Read, Grep, Glob, Edit, Write, Bash",
+    "---",
+    versionHeader(),
+    "",
+    mainSkillBody(),
+    ""
+  ].join("\n");
+  if (updateFile(join6(mainDir, "SKILL.md"), mainContent)) updated = true;
+  for (const skill of TICKET_SKILLS) {
+    const dir = join6(skillsDir, skill.name);
+    mkdirSync3(dir, { recursive: true });
+    const content = [
+      "---",
+      `name: ${skill.name}`,
+      `description: Create a new ${skill.label} ticket in Hot Sheet`,
+      "allowed-tools: Bash",
+      "---",
+      versionHeader(),
+      "",
+      ticketSkillBody(skill),
+      ""
+    ].join("\n");
+    if (updateFile(join6(dir, "SKILL.md"), content)) updated = true;
+  }
+  return updated;
+}
+function ensureCursorRules(cwd) {
+  let updated = false;
+  const rulesDir = join6(cwd, ".cursor", "rules");
+  mkdirSync3(rulesDir, { recursive: true });
+  const mainContent = [
+    "---",
+    "description: Read the Hot Sheet worklist and work through the current priority items",
+    "alwaysApply: false",
+    "---",
+    versionHeader(),
+    "",
+    mainSkillBody(),
+    ""
+  ].join("\n");
+  if (updateFile(join6(rulesDir, "hotsheet.mdc"), mainContent)) updated = true;
+  for (const skill of TICKET_SKILLS) {
+    const content = [
+      "---",
+      `description: Create a new ${skill.label} ticket in Hot Sheet`,
+      "alwaysApply: false",
+      "---",
+      versionHeader(),
+      "",
+      ticketSkillBody(skill),
+      ""
+    ].join("\n");
+    if (updateFile(join6(rulesDir, `${skill.name}.mdc`), content)) updated = true;
+  }
+  return updated;
+}
+function ensureCopilotPrompts(cwd) {
+  let updated = false;
+  const promptsDir = join6(cwd, ".github", "prompts");
+  mkdirSync3(promptsDir, { recursive: true });
+  const mainContent = [
+    "---",
+    "description: Read the Hot Sheet worklist and work through the current priority items",
+    "---",
+    versionHeader(),
+    "",
+    mainSkillBody(),
+    ""
+  ].join("\n");
+  if (updateFile(join6(promptsDir, "hotsheet.prompt.md"), mainContent)) updated = true;
+  for (const skill of TICKET_SKILLS) {
+    const content = [
+      "---",
+      `description: Create a new ${skill.label} ticket in Hot Sheet`,
+      "---",
+      versionHeader(),
+      "",
+      ticketSkillBody(skill),
+      ""
+    ].join("\n");
+    if (updateFile(join6(promptsDir, `${skill.name}.prompt.md`), content)) updated = true;
+  }
+  return updated;
+}
+function ensureWindsurfRules(cwd) {
+  let updated = false;
+  const rulesDir = join6(cwd, ".windsurf", "rules");
+  mkdirSync3(rulesDir, { recursive: true });
+  const mainContent = [
+    "---",
+    "trigger: manual",
+    "description: Read the Hot Sheet worklist and work through the current priority items",
+    "---",
+    versionHeader(),
+    "",
+    mainSkillBody(),
+    ""
+  ].join("\n");
+  if (updateFile(join6(rulesDir, "hotsheet.md"), mainContent)) updated = true;
+  for (const skill of TICKET_SKILLS) {
+    const content = [
+      "---",
+      "trigger: manual",
+      `description: Create a new ${skill.label} ticket in Hot Sheet`,
+      "---",
+      versionHeader(),
+      "",
+      ticketSkillBody(skill),
+      ""
+    ].join("\n");
+    if (updateFile(join6(rulesDir, `${skill.name}.md`), content)) updated = true;
+  }
+  return updated;
+}
+var pendingCreatedFlag = false;
+function ensureSkills() {
+  const cwd = process.cwd();
+  const platforms = [];
+  if (existsSync5(join6(cwd, ".claude"))) {
+    if (ensureClaudeSkills(cwd)) platforms.push("Claude Code");
+  }
+  if (existsSync5(join6(cwd, ".cursor"))) {
+    if (ensureCursorRules(cwd)) platforms.push("Cursor");
+  }
+  if (existsSync5(join6(cwd, ".github", "prompts")) || existsSync5(join6(cwd, ".github", "copilot-instructions.md"))) {
+    if (ensureCopilotPrompts(cwd)) platforms.push("GitHub Copilot");
+  }
+  if (existsSync5(join6(cwd, ".windsurf"))) {
+    if (ensureWindsurfRules(cwd)) platforms.push("Windsurf");
+  }
+  if (platforms.length > 0) {
+    pendingCreatedFlag = true;
+  }
+  return platforms;
+}
+function consumeSkillsCreatedFlag() {
+  const result = pendingCreatedFlag;
+  pendingCreatedFlag = false;
+  return result;
+}
+
 // src/sync/markdown.ts
+import { writeFileSync as writeFileSync5 } from "fs";
+import { join as join7 } from "path";
 var dataDir;
 var port;
 var worklistTimeout = null;
@@ -1371,6 +1925,20 @@ async function syncWorklist() {
     sections.push("- If an API call fails (e.g. connection refused, error response), log a visible warning to the user and continue your work. Do NOT silently skip status updates.");
     sections.push('- Do NOT set tickets to "verified" \u2014 that status is reserved for human review.');
     sections.push("");
+    sections.push("## Creating Tickets");
+    sections.push("");
+    sections.push("You can create new tickets directly via the API. Use this strategically to:");
+    sections.push("- Break up complex tasks into smaller, trackable sub-tickets");
+    sections.push("- Flag implementation decisions that need human review");
+    sections.push("- Record bugs or issues discovered while working");
+    sections.push("- Create follow-up tasks for items outside the current scope");
+    sections.push("");
+    sections.push("To create a ticket:");
+    sections.push(`  \`curl -s -X POST http://localhost:${port}/api/tickets -H "Content-Type: application/json" -d '{"title": "Title", "defaults": {"category": "bug|feature|task|issue|investigation|requirement_change", "up_next": false}}'\``);
+    sections.push("");
+    sections.push('You can also include `"details"` in the defaults object for longer descriptions.');
+    sections.push("Set `up_next: true` only for items that should be prioritized immediately.");
+    sections.push("");
     if (tickets.length === 0) {
       sections.push("No items in the Up Next list.");
     } else {
@@ -1387,7 +1955,7 @@ async function syncWorklist() {
       sections.push(formatCategoryDescriptions(categories));
     }
     sections.push("");
-    writeFileSync(join3(dataDir, "worklist.md"), sections.join("\n"), "utf-8");
+    writeFileSync5(join7(dataDir, "worklist.md"), sections.join("\n"), "utf-8");
   } catch (err) {
     console.error("Failed to sync worklist.md:", err);
   }
@@ -1431,7 +1999,7 @@ async function syncOpenTickets() {
       sections.push(formatCategoryDescriptions(categories));
     }
     sections.push("");
-    writeFileSync(join3(dataDir, "open-tickets.md"), sections.join("\n"), "utf-8");
+    writeFileSync5(join7(dataDir, "open-tickets.md"), sections.join("\n"), "utf-8");
   } catch (err) {
     console.error("Failed to sync open-tickets.md:", err);
   }
@@ -1518,7 +2086,7 @@ apiRoutes.delete("/tickets/:id/hard", async (c) => {
   const attachments = await getAttachments(id);
   for (const att of attachments) {
     try {
-      rmSync3(att.stored_path, { force: true });
+      rmSync5(att.stored_path, { force: true });
     } catch {
     }
   }
@@ -1567,7 +2135,7 @@ apiRoutes.post("/trash/empty", async (c) => {
     const attachments = await getAttachments(ticket.id);
     for (const att of attachments) {
       try {
-        rmSync3(att.stored_path, { force: true });
+        rmSync5(att.stored_path, { force: true });
       } catch {
       }
     }
@@ -1599,12 +2167,12 @@ apiRoutes.post("/tickets/:id/attachments", async (c) => {
   const ext = extname(originalName);
   const baseName = basename(originalName, ext);
   const storedName = `${ticket.ticket_number}_${baseName}${ext}`;
-  const attachDir = join4(dataDir2, "attachments");
-  mkdirSync2(attachDir, { recursive: true });
-  const storedPath = join4(attachDir, storedName);
+  const attachDir = join8(dataDir2, "attachments");
+  mkdirSync4(attachDir, { recursive: true });
+  const storedPath = join8(attachDir, storedName);
   const buffer = Buffer.from(await file.arrayBuffer());
-  const { writeFileSync: writeFileSync4 } = await import("fs");
-  writeFileSync4(storedPath, buffer);
+  const { writeFileSync: writeFileSync7 } = await import("fs");
+  writeFileSync7(storedPath, buffer);
   const attachment = await addAttachment(id, originalName, storedPath);
   scheduleAllSync();
   notifyChange();
@@ -1615,7 +2183,7 @@ apiRoutes.delete("/attachments/:id", async (c) => {
   const attachment = await deleteAttachment(id);
   if (!attachment) return c.json({ error: "Not found" }, 404);
   try {
-    rmSync3(attachment.stored_path, { force: true });
+    rmSync5(attachment.stored_path, { force: true });
   } catch {
   }
   scheduleAllSync();
@@ -1625,12 +2193,12 @@ apiRoutes.delete("/attachments/:id", async (c) => {
 apiRoutes.get("/attachments/file/*", async (c) => {
   const filePath = c.req.path.replace("/api/attachments/file/", "");
   const dataDir2 = c.get("dataDir");
-  const fullPath = join4(dataDir2, "attachments", filePath);
-  if (!existsSync2(fullPath)) {
+  const fullPath = join8(dataDir2, "attachments", filePath);
+  if (!existsSync6(fullPath)) {
     return c.json({ error: "File not found" }, 404);
   }
-  const { readFileSync: readFileSync4 } = await import("fs");
-  const content = readFileSync4(fullPath);
+  const { readFileSync: readFileSync8 } = await import("fs");
+  const content = readFileSync8(fullPath);
   const ext = extname(fullPath).toLowerCase();
   const mimeTypes = {
     ".png": "image/png",
@@ -1663,39 +2231,25 @@ apiRoutes.patch("/settings", async (c) => {
   }
   return c.json({ ok: true });
 });
+apiRoutes.get("/file-settings", async (c) => {
+  const { readFileSettings: readFileSettings2 } = await Promise.resolve().then(() => (init_file_settings(), file_settings_exports));
+  const dataDir2 = c.get("dataDir");
+  return c.json(readFileSettings2(dataDir2));
+});
+apiRoutes.patch("/file-settings", async (c) => {
+  const { writeFileSettings: writeFileSettings2 } = await Promise.resolve().then(() => (init_file_settings(), file_settings_exports));
+  const dataDir2 = c.get("dataDir");
+  const body = await c.req.json();
+  const updated = writeFileSettings2(dataDir2, body);
+  return c.json(updated);
+});
 apiRoutes.get("/worklist-info", (c) => {
   const dataDir2 = c.get("dataDir");
   const cwd = process.cwd();
-  const worklistRel = relative(cwd, join4(dataDir2, "worklist.md"));
+  const worklistRel = relative2(cwd, join8(dataDir2, "worklist.md"));
   const prompt = `Read ${worklistRel} for current work items.`;
-  const claudeDir = join4(cwd, ".claude");
-  let skillCreated = false;
-  if (existsSync2(claudeDir)) {
-    const skillDir = join4(claudeDir, "skills", "hotsheet");
-    const skillFile = join4(skillDir, "SKILL.md");
-    if (!existsSync2(skillFile)) {
-      mkdirSync2(skillDir, { recursive: true });
-      const skillContent = [
-        "---",
-        "name: hotsheet",
-        "description: Read the Hot Sheet worklist and work through the current priority items",
-        "allowed-tools: Read, Grep, Glob, Edit, Write, Bash",
-        "---",
-        "",
-        `Read \`${worklistRel}\` and work through the tickets in priority order.`,
-        "",
-        "For each ticket:",
-        "1. Read the ticket details carefully",
-        "2. Implement the work described",
-        "3. When complete, mark it done via the Hot Sheet UI",
-        "",
-        "Work through them in order of priority, where reasonable.",
-        ""
-      ].join("\n");
-      writeFileSync2(skillFile, skillContent, "utf-8");
-      skillCreated = true;
-    }
-  }
+  ensureSkills();
+  const skillCreated = consumeSkillsCreatedFlag();
   return c.json({ prompt, skillCreated });
 });
 apiRoutes.get("/gitignore/status", async (c) => {
@@ -1710,8 +2264,58 @@ apiRoutes.post("/gitignore/add", async (c) => {
   return c.json({ ok: true });
 });
 
-// src/routes/pages.tsx
+// src/routes/backups.ts
 import { Hono as Hono2 } from "hono";
+var backupRoutes = new Hono2();
+backupRoutes.get("/", (c) => {
+  const dataDir2 = c.get("dataDir");
+  const backups = listBackups(dataDir2);
+  return c.json({ backups });
+});
+backupRoutes.post("/create", async (c) => {
+  const dataDir2 = c.get("dataDir");
+  const body = await c.req.json();
+  const info = await createBackup(dataDir2, body.tier);
+  if (!info) return c.json({ error: "Backup already in progress" }, 409);
+  return c.json(info);
+});
+backupRoutes.post("/now", async (c) => {
+  const dataDir2 = c.get("dataDir");
+  const info = await triggerManualBackup(dataDir2);
+  if (!info) return c.json({ error: "Backup already in progress" }, 409);
+  return c.json(info);
+});
+backupRoutes.get("/preview/:tier/:filename", async (c) => {
+  const dataDir2 = c.get("dataDir");
+  const tier = c.req.param("tier");
+  const filename = c.req.param("filename");
+  try {
+    const result = await loadBackupForPreview(dataDir2, tier, filename);
+    return c.json(result);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Preview failed";
+    return c.json({ error: msg }, 400);
+  }
+});
+backupRoutes.post("/preview/cleanup", async (c) => {
+  await cleanupPreview();
+  return c.json({ ok: true });
+});
+backupRoutes.post("/restore", async (c) => {
+  const dataDir2 = c.get("dataDir");
+  const body = await c.req.json();
+  try {
+    await restoreBackup(dataDir2, body.tier, body.filename);
+    scheduleAllSync();
+    return c.json({ ok: true });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Restore failed";
+    return c.json({ error: msg }, 500);
+  }
+});
+
+// src/routes/pages.tsx
+import { Hono as Hono3 } from "hono";
 
 // src/utils/escapeHtml.ts
 function escapeHtml(str) {
@@ -1799,7 +2403,7 @@ function Layout({ title, children }) {
 }
 
 // src/routes/pages.tsx
-var pageRoutes = new Hono2();
+var pageRoutes = new Hono3();
 pageRoutes.get("/", (c) => {
   const html = /* @__PURE__ */ jsx(Layout, { title: "Hot Sheet", children: [
     /* @__PURE__ */ jsx("div", { className: "app", children: [
@@ -1825,6 +2429,17 @@ pageRoutes.get("/", (c) => {
           /* @__PURE__ */ jsx("button", { className: "settings-btn", id: "settings-btn", title: "Settings", children: raw("&#9881;") })
         ] })
       ] }),
+      /* @__PURE__ */ jsx("div", { id: "backup-preview-banner", className: "backup-preview-banner", style: "display:none", children: [
+        /* @__PURE__ */ jsx("span", { id: "backup-preview-label", children: "Previewing backup..." }),
+        /* @__PURE__ */ jsx("div", { className: "backup-preview-actions", children: [
+          /* @__PURE__ */ jsx("button", { id: "backup-restore-btn", className: "btn btn-sm btn-danger", children: "Restore This Backup" }),
+          /* @__PURE__ */ jsx("button", { id: "backup-cancel-btn", className: "btn btn-sm", children: "Cancel Preview" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("div", { id: "skills-banner", className: "skills-banner", style: "display:none", children: [
+        /* @__PURE__ */ jsx("span", { children: "AI tool skills created. Restart your AI tool to use the new ticket creation skills (hs-bug, hs-feature, etc.)." }),
+        /* @__PURE__ */ jsx("button", { id: "skills-banner-dismiss", className: "btn btn-sm", children: "Dismiss" })
+      ] }),
       /* @__PURE__ */ jsx("div", { className: "app-body", children: [
         /* @__PURE__ */ jsx("nav", { className: "sidebar", children: [
           /* @__PURE__ */ jsx("div", { className: "sidebar-copy-prompt", id: "copy-prompt-section", style: "display:none", children: /* @__PURE__ */ jsx("button", { className: "copy-prompt-btn", id: "copy-prompt-btn", title: "Copy worklist prompt to clipboard", children: [
@@ -2025,6 +2640,18 @@ pageRoutes.get("/", (c) => {
         /* @__PURE__ */ jsx("div", { className: "settings-field", children: [
           /* @__PURE__ */ jsx("label", { children: "Auto-clear verified after (days)" }),
           /* @__PURE__ */ jsx("input", { type: "number", id: "settings-verified-days", min: "1", value: "30" })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "settings-section", children: [
+          /* @__PURE__ */ jsx("div", { className: "settings-section-header", children: [
+            /* @__PURE__ */ jsx("h3", { children: "Database Backups" }),
+            /* @__PURE__ */ jsx("button", { className: "btn btn-sm", id: "backup-now-btn", children: "Backup Now" })
+          ] }),
+          /* @__PURE__ */ jsx("div", { className: "settings-field", children: [
+            /* @__PURE__ */ jsx("label", { children: "Backup storage location" }),
+            /* @__PURE__ */ jsx("input", { type: "text", id: "settings-backup-dir", placeholder: "Default: .hotsheet/backups" }),
+            /* @__PURE__ */ jsx("span", { className: "settings-hint", id: "settings-backup-dir-hint", children: "Leave empty to use the default location inside the data directory." })
+          ] }),
+          /* @__PURE__ */ jsx("div", { id: "backup-list", className: "backup-list", children: "Loading backups..." })
         ] })
       ] })
     ] }) })
@@ -2045,22 +2672,23 @@ function tryServe(fetch, port2) {
   });
 }
 async function startServer(port2, dataDir2, options) {
-  const app = new Hono3();
+  const app = new Hono4();
   app.use("*", async (c, next) => {
     c.set("dataDir", dataDir2);
     await next();
   });
   const selfDir = dirname(fileURLToPath(import.meta.url));
-  const distDir = existsSync3(join5(selfDir, "client", "styles.css")) ? join5(selfDir, "client") : join5(selfDir, "..", "dist", "client");
+  const distDir = existsSync7(join9(selfDir, "client", "styles.css")) ? join9(selfDir, "client") : join9(selfDir, "..", "dist", "client");
   app.get("/static/styles.css", (c) => {
-    const css = readFileSync2(join5(distDir, "styles.css"), "utf-8");
+    const css = readFileSync6(join9(distDir, "styles.css"), "utf-8");
     return c.text(css, 200, { "Content-Type": "text/css", "Cache-Control": "no-cache" });
   });
   app.get("/static/app.js", (c) => {
-    const js = readFileSync2(join5(distDir, "app.global.js"), "utf-8");
+    const js = readFileSync6(join9(distDir, "app.global.js"), "utf-8");
     return c.text(js, 200, { "Content-Type": "application/javascript", "Cache-Control": "no-cache" });
   });
   app.route("/api", apiRoutes);
+  app.route("/api/backups", backupRoutes);
   app.route("/", pageRoutes);
   let actualPort = port2;
   for (let attempt = 0; attempt < 20; attempt++) {
@@ -2098,18 +2726,18 @@ async function startServer(port2, dataDir2, options) {
 }
 
 // src/update-check.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { get } from "https";
 import { homedir } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join10 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var DATA_DIR = join6(homedir(), ".hotsheet");
-var CHECK_FILE = join6(DATA_DIR, "last-update-check");
+var DATA_DIR = join10(homedir(), ".hotsheet");
+var CHECK_FILE = join10(DATA_DIR, "last-update-check");
 var PACKAGE_NAME = "hotsheet";
 function getCurrentVersion() {
   try {
     const dir = dirname2(fileURLToPath2(import.meta.url));
-    const pkg = JSON.parse(readFileSync3(join6(dir, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync7(join10(dir, "..", "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";
@@ -2117,16 +2745,16 @@ function getCurrentVersion() {
 }
 function getLastCheckDate() {
   try {
-    if (existsSync4(CHECK_FILE)) {
-      return readFileSync3(CHECK_FILE, "utf-8").trim();
+    if (existsSync8(CHECK_FILE)) {
+      return readFileSync7(CHECK_FILE, "utf-8").trim();
     }
   } catch {
   }
   return null;
 }
 function saveCheckDate() {
-  mkdirSync3(DATA_DIR, { recursive: true });
-  writeFileSync3(CHECK_FILE, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), "utf-8");
+  mkdirSync5(DATA_DIR, { recursive: true });
+  writeFileSync6(CHECK_FILE, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10), "utf-8");
 }
 function isFirstUseToday() {
   const last = getLastCheckDate();
@@ -2231,7 +2859,7 @@ Examples:
 function parseArgs(argv) {
   const args = argv.slice(2);
   let port2 = 4174;
-  let dataDir2 = join7(process.cwd(), ".hotsheet");
+  let dataDir2 = join11(process.cwd(), ".hotsheet");
   let demo = null;
   let forceUpdateCheck = false;
   let noOpen = false;
@@ -2298,13 +2926,14 @@ async function main() {
       }
       process.exit(1);
     }
-    dataDir2 = join7(tmpdir(), `hotsheet-demo-${demo}-${Date.now()}`);
+    dataDir2 = join11(tmpdir(), `hotsheet-demo-${demo}-${Date.now()}`);
     console.log(`
   DEMO MODE: ${scenario.label}
 `);
   }
-  mkdirSync4(dataDir2, { recursive: true });
+  mkdirSync6(dataDir2, { recursive: true });
   if (demo === null) {
+    acquireLock(dataDir2);
     ensureGitignore(process.cwd());
   }
   setDataDir(dataDir2);
@@ -2319,6 +2948,16 @@ async function main() {
   const actualPort = await startServer(port2, dataDir2, { noOpen, strictPort });
   initMarkdownSync(dataDir2, actualPort);
   scheduleAllSync();
+  initSkills(actualPort, dataDir2);
+  const updatedPlatforms = ensureSkills();
+  if (updatedPlatforms.length > 0) {
+    console.log(`
+  AI tool skills created/updated for: ${updatedPlatforms.join(", ")}`);
+    console.log("  Restart your AI tool to pick up the new ticket creation skills.\n");
+  }
+  if (demo === null) {
+    initBackupScheduler(dataDir2);
+  }
 }
 main().catch((err) => {
   console.error(err);