@starlove/orbit 1.4.1 → 2.0.0

package/src/core/attachments.js

@@ -1,238 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, normalize, sep } from "node:path";
-import { boardById, ticketById } from "./queries.js";
-import { requireBoardAccess, requirePermission } from "./auth.js";
-import { tx } from "./db.js";
-import { recordEvent } from "./events.js";
-import { bumpTicketUpdatedAt } from "./tickets.js";
-import { httpError, id, now } from "./util.js";
-
-export const MAX_IMAGE_ATTACHMENT_BYTES = 10 * 1024 * 1024;
-
-const IMAGE_EXTENSIONS = new Map([
-  ["image/png", ".png"],
-  ["image/jpeg", ".jpg"],
-  ["image/gif", ".gif"],
-  ["image/webp", ".webp"],
-  ["image/svg+xml", ".svg"],
-  ["image/bmp", ".bmp"],
-  ["image/avif", ".avif"]
-]);
-
-export function attachmentStorageRoot(boardRow) {
-  return join(dirname(boardRow.db_path), "attachments");
-}
-
-function ticketAttachmentDir(boardRow, ticketId) {
-  return join(attachmentStorageRoot(boardRow), "tickets", ticketId);
-}
-
-function safeOriginalName(value) {
-  const name = String(value || "image").replace(/[\0\r\n]/g, "").trim();
-  return name.slice(0, 240) || "image";
-}
-
-function normalizeImageMime(value) {
-  const mime = String(value || "").split(";")[0].trim().toLowerCase();
-  if (!IMAGE_EXTENSIONS.has(mime)) throw httpError(415, "unsupported_attachment_type");
-  return mime;
-}
-
-function extensionFor(mime, originalName = "") {
-  const originalExt = extname(originalName).toLowerCase();
-  if ([...IMAGE_EXTENSIONS.values()].includes(originalExt)) return originalExt;
-  return IMAGE_EXTENSIONS.get(mime) || ".img";
-}
-
-function relativeStoredPath(ticketId, attachmentId, mime, originalName) {
-  return normalize(join("tickets", ticketId, `${attachmentId}${extensionFor(mime, originalName)}`)).replace(/\\/g, "/");
-}
-
-function resolveStoredPath(boardRow, storedPath) {
-  const root = attachmentStorageRoot(boardRow);
-  const abs = join(root, storedPath);
-  const normalizedRoot = normalize(root + sep);
-  const normalizedAbs = normalize(abs);
-  if (!normalizedAbs.startsWith(normalizedRoot)) throw httpError(400, "invalid_attachment_path");
-  return normalizedAbs;
-}
-
-function assertTicket(ctx, ticketId, write = false) {
-  const { db, board, actor } = ctx;
-  const ticket = ticketById(db, ticketId);
-  if (!ticket || ticket.board_id !== board.id) throw httpError(404, "ticket_not_found");
-  requireBoardAccess(actor, boardById(db, ticket.board_id));
-  if (write) requirePermission(actor, "write");
-  return ticket;
-}
-
-function rowToAttachment(boardRow, row) {
-  const path = resolveStoredPath(boardRow, row.stored_path);
-  let missing = true;
-  let size = row.size_bytes;
-  try {
-    const stat = statSync(path);
-    missing = !stat.isFile();
-    if (!missing) size = stat.size;
-  } catch {
-    missing = true;
-  }
-  return {
-    id: row.id,
-    ticket_id: row.ticket_id,
-    board_id: row.board_id,
-    original_name: row.original_name,
-    mime_type: row.mime_type,
-    size_bytes: row.size_bytes,
-    sha256: row.sha256,
-    stored_path: row.stored_path,
-    created_by: row.created_by,
-    created_at: row.created_at,
-    missing,
-    content_url: missing ? null : `/api/tickets/${encodeURIComponent(row.ticket_id)}/attachments/${encodeURIComponent(row.id)}/content`,
-    filesystem_size_bytes: missing ? null : size
-  };
-}
-
-export function listTicketAttachments(ticketId, ctx) {
-  assertTicket(ctx, ticketId);
-  const rows = ctx.db
-    .prepare("SELECT * FROM ticket_attachments WHERE ticket_id = ? ORDER BY created_at ASC")
-    .all(ticketId);
-  return { attachments: rows.map((row) => rowToAttachment(ctx.board, row)) };
-}
-
-export function getTicketAttachmentContent(ticketId, attachmentId, ctx) {
-  assertTicket(ctx, ticketId);
-  const row = ctx.db
-    .prepare("SELECT * FROM ticket_attachments WHERE id = ? AND ticket_id = ?")
-    .get(attachmentId, ticketId);
-  if (!row) throw httpError(404, "attachment_not_found");
-  const filePath = resolveStoredPath(ctx.board, row.stored_path);
-  if (!existsSync(filePath)) throw httpError(404, "attachment_file_missing");
-  return { row, filePath };
-}
-
-export function createTicketAttachment(ticketId, input, ctx) {
-  const ticket = assertTicket(ctx, ticketId, true);
-  const mime = normalizeImageMime(input.mime_type);
-  const bytes = Buffer.isBuffer(input.bytes) ? input.bytes : Buffer.from(input.bytes || []);
-  if (bytes.length === 0) throw httpError(400, "empty_attachment");
-  if (bytes.length > MAX_IMAGE_ATTACHMENT_BYTES) throw httpError(413, "attachment_too_large");
-  const originalName = safeOriginalName(input.original_name);
-  const attachmentId = id();
-  const storedPath = relativeStoredPath(ticketId, attachmentId, mime, originalName);
-  const filePath = resolveStoredPath(ctx.board, storedPath);
-  const hash = createHash("sha256").update(bytes).digest("hex");
-  const time = now();
-
-  mkdirSync(ticketAttachmentDir(ctx.board, ticketId), { recursive: true });
-  writeFileSync(filePath, bytes, { flag: "wx" });
-
-  try {
-    return tx(ctx.db, () => {
-      ctx.db.prepare(
-        `INSERT INTO ticket_attachments
-         (id, ticket_id, board_id, original_name, stored_path, mime_type, size_bytes, sha256, created_by, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      ).run(attachmentId, ticketId, ticket.board_id, originalName, storedPath, mime, bytes.length, hash, ctx.actor.name, time);
-      ctx.db.prepare("UPDATE tickets SET updated_at = ? WHERE id = ?").run(time, ticketId);
-      recordEvent(ctx.db, ticket.board_id, "attachment_created", ticketId, ctx.actor.name, {
-        attachment_id: attachmentId,
-        original_name: originalName,
-        mime_type: mime,
-        size_bytes: bytes.length,
-        sha256: hash
-      });
-      bumpTicketUpdatedAt(ctx.db, ticket.parent_ticket_id, time);
-      return rowToAttachment(ctx.board, ctx.db.prepare("SELECT * FROM ticket_attachments WHERE id = ?").get(attachmentId));
-    });
-  } catch (error) {
-    try { unlinkSync(filePath); } catch {}
-    throw error;
-  }
-}
-
-export function deleteTicketAttachment(ticketId, attachmentId, ctx) {
-  const ticket = assertTicket(ctx, ticketId, true);
-  const row = ctx.db
-    .prepare("SELECT * FROM ticket_attachments WHERE id = ? AND ticket_id = ?")
-    .get(attachmentId, ticketId);
-  if (!row) throw httpError(404, "attachment_not_found");
-  const filePath = resolveStoredPath(ctx.board, row.stored_path);
-  return tx(ctx.db, () => {
-    ctx.db.prepare("DELETE FROM ticket_attachments WHERE id = ?").run(attachmentId);
-    const time = now();
-    ctx.db.prepare("UPDATE tickets SET updated_at = ? WHERE id = ?").run(time, ticketId);
-    recordEvent(ctx.db, ticket.board_id, "attachment_deleted", ticketId, ctx.actor.name, {
-      attachment_id: attachmentId,
-      original_name: row.original_name
-    });
-    bumpTicketUpdatedAt(ctx.db, ticket.parent_ticket_id, time);
-    try { unlinkSync(filePath); } catch {}
-    return { ok: true, deleted_id: attachmentId };
-  });
-}
-
-export function attachmentRowsForBoard(db, boardId) {
-  return db
-    .prepare("SELECT * FROM ticket_attachments WHERE board_id = ? ORDER BY created_at ASC")
-    .all(boardId);
-}
-
-export function serializeAttachmentForExport(boardRow, row, includeBytes = false) {
-  const attachment = rowToAttachment(boardRow, row);
-  if (!includeBytes || attachment.missing) {
-    return { ...attachment, data_base64: null, included: false };
-  }
-  const filePath = resolveStoredPath(boardRow, row.stored_path);
-  const data = readFileSync(filePath);
-  return {
-    ...attachment,
-    data_base64: data.toString("base64"),
-    included: true,
-    missing: false
-  };
-}
-
-export function importAttachmentRows(snapshot, ctx, targetBoardId) {
-  const rows = Array.isArray(snapshot.attachments) ? snapshot.attachments : [];
-  for (const attachment of rows) {
-    const attachmentId = attachment.id || id();
-    const ticketId = attachment.ticket_id;
-    if (!ticketId || !ctx.db.prepare("SELECT 1 FROM tickets WHERE id = ?").get(ticketId)) continue;
-    const mime = normalizeImageMime(attachment.mime_type || "image/png");
-    const originalName = safeOriginalName(attachment.original_name);
-    const storedPath = relativeStoredPath(ticketId, attachmentId, mime, originalName);
-    let size = Number(attachment.size_bytes || 0);
-    let sha = String(attachment.sha256 || "");
-
-    if (attachment.data_base64) {
-      const bytes = Buffer.from(String(attachment.data_base64), "base64");
-      if (bytes.length > MAX_IMAGE_ATTACHMENT_BYTES) throw httpError(413, "attachment_too_large");
-      size = bytes.length;
-      sha = createHash("sha256").update(bytes).digest("hex");
-      const filePath = resolveStoredPath(ctx.board, storedPath);
-      mkdirSync(dirname(filePath), { recursive: true });
-      writeFileSync(filePath, bytes);
-    }
-
-    ctx.db.prepare(
-      `INSERT OR IGNORE INTO ticket_attachments
-       (id, ticket_id, board_id, original_name, stored_path, mime_type, size_bytes, sha256, created_by, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      attachmentId,
-      ticketId,
-      targetBoardId,
-      originalName,
-      storedPath,
-      mime,
-      size,
-      sha,
-      attachment.created_by || "import",
-      attachment.created_at || now()
-    );
-  }
-}

package/src/core/auth.js

@@ -1,85 +0,0 @@
-export function localOwnerActor() {
-  return {
-    id: "local",
-    name: "local",
-    type: "human",
-    role: "owner",
-    permissions: ["owner", "read", "write", "claim"],
-    boards: ["*"]
-  };
-}
-
-export function localAgentActor() {
-  return {
-    id: "local-agent",
-    name: "agent",
-    type: "agent",
-    role: "owner",
-    permissions: ["owner", "read", "write", "claim"],
-    boards: ["*"]
-  };
-}
-
-function headerValue(req, name) {
-  const value = req?.headers?.[name.toLowerCase()];
-  if (Array.isArray(value)) return value[0] || "";
-  return String(value || "");
-}
-
-function cleanActorField(value, fallback) {
-  const clean = String(value || "")
-    .trim()
-    .replace(/\s+/g, " ")
-    .slice(0, 80);
-  return clean || fallback;
-}
-
-function actorIdFromName(name) {
-  return String(name || "agent")
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80) || "agent";
-}
-
-export function actorFromHttpRequest(req) {
-  const actorType = headerValue(req, "x-orbit-actor-type").trim().toLowerCase();
-  const agentName = headerValue(req, "x-orbit-agent-name");
-  if (actorType !== "agent" && !agentName.trim()) return localOwnerActor();
-
-  const name = cleanActorField(headerValue(req, "x-orbit-actor-name") || agentName, "agent");
-  const id = cleanActorField(headerValue(req, "x-orbit-actor-id"), actorIdFromName(name));
-  return {
-    ...localAgentActor(),
-    id,
-    name
-  };
-}
-
-export function authenticate() {
-  return localOwnerActor();
-}
-
-export function actorFromToken() {
-  return localOwnerActor();
-}
-
-export function canAccessBoard() {
-  return true;
-}
-
-export function requireBoardAccess() {}
-
-export function requireOwner() {}
-
-export function requirePermission() {}
-
-export function publicActor(actor) {
-  return {
-    id: actor.id,
-    name: actor.name,
-    type: actor.type,
-    role: actor.role,
-    permissions: actor.permissions
-  };
-}

package/src/core/backups.js

@@ -1,142 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { closeConnection, getRegistry, hasConnection, openConnection } from "./db.js";
-import { BACKUP_DIR, REGISTRY_DB_PATH } from "./paths.js";
-import { now } from "./util.js";
-
-const DEFAULT_RETENTION = 30;
-const DEFAULT_AUTO_DELAY_MS = 120_000;
-const scheduledBoardBackups = new Map();
-
-function backupsEnabled() {
-  return !["0", "false", "off"].includes(String(process.env.ORBIT_AUTO_BACKUPS || "1").toLowerCase());
-}
-
-function retentionLimit() {
-  const parsed = Number(process.env.ORBIT_BACKUP_RETENTION || DEFAULT_RETENTION);
-  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_RETENTION;
-  return Math.floor(parsed);
-}
-
-function cleanSegment(value) {
-  return String(value || "unknown")
-    .trim()
-    .replace(/[^a-zA-Z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 80) || "unknown";
-}
-
-function timestampForPath() {
-  return now().replace(/[:.]/g, "-");
-}
-
-function sqlLiteral(value) {
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-
-function pruneBackups(dir, suffix) {
-  if (!existsSync(dir)) return;
-  const limit = retentionLimit();
-  const files = readdirSync(dir)
-    .filter((name) => name.endsWith(suffix))
-    .sort()
-    .reverse();
-  for (const stale of files.slice(limit)) {
-    unlinkSync(join(dir, stale));
-    const manifest = join(dir, `${stale}.json`);
-    if (existsSync(manifest)) unlinkSync(manifest);
-  }
-}
-
-function latestBackupStartsWith(dir, prefix, suffix) {
-  if (!existsSync(dir)) return false;
-  return readdirSync(dir).some((name) => name.startsWith(prefix) && name.endsWith(suffix));
-}
-
-function writeBackup(db, targetPath) {
-  mkdirSync(dirname(targetPath), { recursive: true });
-  db.exec(`VACUUM INTO ${sqlLiteral(targetPath)};`);
-}
-
-function writeManifest(targetPath, payload) {
-  writeFileSync(`${targetPath}.json`, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-
-function automaticDelayMs() {
-  const parsed = Number(process.env.ORBIT_AUTO_BACKUP_DELAY_MS || DEFAULT_AUTO_DELAY_MS);
-  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_AUTO_DELAY_MS;
-  return Math.floor(parsed);
-}
-
-export function backupBoardDatabase(boardRow, db, reason = "manual", options = {}) {
-  if (!backupsEnabled()) return null;
-  const boardId = cleanSegment(boardRow.id);
-  const slug = cleanSegment(boardRow.slug);
-  const dir = join(BACKUP_DIR, "boards", boardId);
-  const dayPrefix = `${now().slice(0, 10)}T`;
-  if (options.oncePerDay && latestBackupStartsWith(dir, dayPrefix, ".board.db")) return null;
-
-  const filename = `${timestampForPath()}-${cleanSegment(reason)}-${slug}.board.db`;
-  const targetPath = join(dir, filename);
-  writeBackup(db, targetPath);
-  writeManifest(targetPath, {
-    kind: "board",
-    reason,
-    created_at: now(),
-    board_id: boardRow.id,
-    slug: boardRow.slug,
-    name: boardRow.name,
-    repo_path: boardRow.repo_path,
-    db_path: boardRow.db_path
-  });
-  pruneBackups(dir, ".board.db");
-  return { path: targetPath };
-}
-
-export function scheduleAutomaticBoardBackup(boardRow, db) {
-  if (!backupsEnabled() || !boardRow?.id || !db) return;
-  const existing = scheduledBoardBackups.get(boardRow.id);
-  if (existing) clearTimeout(existing);
-
-  const timer = setTimeout(() => {
-    scheduledBoardBackups.delete(boardRow.id);
-    const hadBoardConnection = hasConnection(boardRow.db_path);
-    const hadRegistryConnection = hasConnection(REGISTRY_DB_PATH);
-    const backupDb = openConnection(boardRow.db_path);
-    try {
-      backupBoardDatabase(boardRow, backupDb, "auto-write");
-      backupRegistry("auto-write");
-    } catch (error) {
-      console.warn(`[orbit] Automatic write backup failed for "${boardRow.slug}": ${error.message}`);
-    } finally {
-      if (!hadBoardConnection) closeConnection(boardRow.db_path);
-      if (!hadRegistryConnection) closeConnection(REGISTRY_DB_PATH);
-    }
-  }, automaticDelayMs());
-  timer.unref?.();
-  scheduledBoardBackups.set(boardRow.id, timer);
-}
-
-export function cancelAutomaticBoardBackup(boardId) {
-  const existing = scheduledBoardBackups.get(boardId);
-  if (!existing) return;
-  clearTimeout(existing);
-  scheduledBoardBackups.delete(boardId);
-}
-
-export function backupRegistry(reason = "manual", options = {}) {
-  if (!backupsEnabled()) return null;
-  const dir = join(BACKUP_DIR, "registry");
-  const dayPrefix = `${now().slice(0, 10)}T`;
-  if (options.oncePerDay && latestBackupStartsWith(dir, dayPrefix, ".registry.db")) return null;
-
-  const targetPath = join(dir, `${timestampForPath()}-${cleanSegment(reason)}.registry.db`);
-  writeBackup(getRegistry(), targetPath);
-  writeManifest(targetPath, {
-    kind: "registry",
-    reason,
-    created_at: now()
-  });
-  pruneBackups(dir, ".registry.db");
-  return { path: targetPath };
-}

package/src/core/board.js

@@ -1,148 +0,0 @@
-// Barrel module + startup orchestration.
-//
-// Startup contract:
-//   1. Ensure the registry DB and its schema exist.
-//   2. If the registry has zero boards, create a first board under
-//      PROJECT_ROOT and seed it. This is the open-source one-command-startup
-//      ergonomic — drop into a repo, run the server, get a board.
-//   3. Iterate every registry board, ensuring the per-board schema exists
-//      and reindexing FTS for that board's DB. No "active board" singleton:
-//      each iteration opens its own connection.
-//   4. When launched through `orbit run`, refresh Orbit-managed
-//      SKILL-ORBIT.md copies for registered repo paths.
-//
-// Beyond startup this module just re-exports per-domain functions for
-// `src/server.js` and `src/mcp-server.js` to consume.
-
-import { existsSync, mkdirSync } from "node:fs";
-import { resolve } from "node:path";
-import "./paths.js";
-import { syncSkillOrbitMd } from "./agents-md.js";
-import { createBoardSchema, createRegistrySchema } from "./db.js";
-import { reindexAllTickets } from "./tickets.js";
-import { deleteBoard, listBoards, openBoardDb, syncRegistryFromBoardDb } from "./registry.js";
-import { provisionRepoBoard } from "./provision-repo-board.js";
-import { migrateInRepoBoards } from "./migrate.js";
-import { id, slugify } from "./util.js";
-import {
-  DATA_DIR,
-  EXPORT_DIR,
-  BACKUP_DIR,
-  PORT,
-  PROJECT_ROOT,
-  PUBLIC_DIR,
-  REGISTRY_DB_PATH,
-  ROOT_DIR
-} from "./paths.js";
-
-function ensureWorkspace() {
-  mkdirSync(DATA_DIR, { recursive: true });
-  createRegistrySchema();
-}
-
-function ensureFirstBoard() {
-  if (listBoards().length > 0) return;
-  // Bootstrap a first board under PROJECT_ROOT so the server is useful out of
-  // the box. Shared logic with `orbit init` (provision-repo-board.js).
-  provisionRepoBoard(PROJECT_ROOT);
-}
-
-function ensureSchemaForEveryBoard() {
-  for (const row of listBoards()) {
-    if (!existsSync(row.db_path)) {
-      console.warn(
-        `[orbit] Removing stale registry row for "${row.slug}": database file missing (${row.db_path}).`
-      );
-      deleteBoard(row.id);
-      continue;
-    }
-    const db = openBoardDb(row);
-    createBoardSchema(db);
-    reindexAllTickets(db);
-    syncRegistryFromBoardDb(row, db);
-  }
-}
-
-function syncManagedSkillOrbitFiles() {
-  const skillSrc = resolve(ROOT_DIR, "SKILL-ORBIT.md");
-  for (const row of listBoards()) {
-    if (!row.repo_path) continue;
-    // Respect boards created without "Generate AI helper files" — don't
-    // re-push SKILL-ORBIT.md into a repo the user opted out of.
-    if (row.manage_helper_files === 0) continue;
-    try {
-      const result = syncSkillOrbitMd(row.repo_path, skillSrc);
-      if (result.status === "missing_source") {
-        console.warn(`[orbit] Missing managed SKILL-ORBIT.md source at ${skillSrc}; skipped repo guidance refresh.`);
-        return;
-      }
-      if (result.status === "written") {
-        console.log(`[orbit] Refreshed managed SKILL-ORBIT.md in ${row.repo_path}`);
-      }
-    } catch (error) {
-      console.warn(`[orbit] Could not refresh SKILL-ORBIT.md in ${row.repo_path}: ${error.message}`);
-    }
-  }
-}
-
-ensureWorkspace();
-// Move any per-board SQLite files that still live in in-repo .orbit/ directories
-// into the central DATA_DIR/boards/<slug>/ store. Must run before
-// ensureSchemaForEveryBoard so all connections open against the canonical paths.
-migrateInRepoBoards();
-// Reconcile the registry against disk *before* deciding whether to bootstrap a
-// first board — otherwise a stale row from a deleted .orbit/ folder makes
-// listBoards() non-empty and we never re-seed.
-ensureSchemaForEveryBoard();
-ensureFirstBoard();
-if (process.env.ORBIT_SYNC_MANAGED_SKILL_ORBIT === "1") {
-  syncManagedSkillOrbitFiles();
-}
-
-export const boardRuntime = {
-  rootDir: ROOT_DIR,
-  publicDir: PUBLIC_DIR,
-  projectRoot: PROJECT_ROOT,
-  dataDir: DATA_DIR,
-  registryPath: REGISTRY_DB_PATH,
-  exportDir: EXPORT_DIR,
-  backupDir: BACKUP_DIR,
-  port: PORT
-};
-
-export function startupSummary(port = PORT, host = "localhost") {
-  const rows = listBoards();
-  return {
-    url: `http://${host}:${port}`,
-    registryPath: REGISTRY_DB_PATH,
-    boardCount: rows.length,
-    boardPaths: rows.map((row) => row.db_path)
-  };
-}
-
-export { localOwnerActor, localAgentActor } from "./auth.js";
-export { startSSEStream } from "./events.js";
-export { sendEmpty, sendJson, serveStatic } from "./http.js";
-export { handleApi } from "./router.js";
-export { getBootstrap } from "./bootstrap.js";
-export {
-  createBoard,
-  createBoardEntry,
-  getBoardContext,
-  insertBoardEntry,
-  updateBoard,
-  updateBoardEntry,
-  boardManual
-} from "./boards.js";
-export { archiveTicket, createComment, createTicket, deleteTicket, restoreTicket, updateTicket } from "./tickets.js";
-export { createReviewVerdict, getReviewVerdict, listReviewVerdicts } from "./review-verdicts.js";
-export { archivedTicketsForBoard } from "./queries.js";
-export { getTicketBlockers, getTicketRelations } from "./relations.js";
-export { checkpointTicket, claimNext, completeTicket, getAgentDispatchPacket, getContextPack, getContextPackFull, readComments, readTicket } from "./agent.js";
-export { searchTickets } from "./search.js";
-export { getTicketMarkdownArtifact, storeTicketMarkdownArtifact } from "./artifacts.js";
-export { exportBoard } from "./snapshots.js";
-
-// Helpers for ad-hoc id/slug minting in callers (e.g. MCP tools that mint
-// per-process tokens). Intentionally kept tiny and side-effect-free.
-export const mint = { id, slugify };