@mean-weasel/lineage 0.1.7 → 0.1.9

package/dist/cli/lineage.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, join as join7, resolve as resolve5 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -283,8 +283,8 @@ function isPackageRoot(path) {
   const packageJson = join3(path, "package.json");
   if (!existsSync3(packageJson)) return false;
   try {
-    const packageInfo = JSON.parse(readFileSync2(packageJson, "utf8"));
-    return packageInfo.name === "@mean-weasel/lineage";
+    const packageInfo2 = JSON.parse(readFileSync2(packageJson, "utf8"));
+    return packageInfo2.name === "@mean-weasel/lineage";
   } catch {
     return false;
   }
@@ -328,6 +328,13 @@ function catalogPath(project = defaultProject) {
 function fixtureCatalogPath(project = defaultProject) {
   return join3(repoRoot, "fixtures", cleanProject(project), "assets", "catalog.json");
 }
+function resolvedCatalogPath(project = defaultProject) {
+  const path = catalogPath(project);
+  if (existsSync3(path)) return path;
+  const clean = cleanProject(project);
+  if (clean === defaultProject && existsSync3(fixtureCatalogPath(clean))) return fixtureCatalogPath(clean);
+  return path;
+}
 function normalizeCatalog(catalog, fallbackProject = defaultProject) {
   const project = cleanProject(catalog.project || catalog.product || fallbackProject);
   const product = catalog.product || project;
@@ -570,6 +577,10 @@ function listAssets(project = defaultProject, options = {}) {
     error
   };
 }
+function validateProject(project = defaultProject) {
+  const catalog = loadCatalog(project);
+  return { project: catalog.project, product: catalog.product, catalogPath: resolvedCatalogPath(project), default_bucket: catalog.default_bucket, default_region: catalog.default_region, asset_count: catalog.assets.length };
+}
 
 // src/server/assetLineageDb.ts
 var require2 = createRequire(import.meta.url);
@@ -2223,6 +2234,17 @@ function seedLegacyWorkspaces(database, project) {
     );
   }
 }
+function listRows(database, project) {
+  return database.prepare(`
+    select * from lineage_workspaces
+    where project_id = ?
+    order by
+      case status when 'active' then 0 when 'paused' then 1 else 2 end,
+      active_at desc nulls last,
+      updated_at desc,
+      title
+  `).all(project).map(rowToWorkspace);
+}
 function activeWorkspace(database, project) {
   const row = database.prepare(`
     select * from lineage_workspaces
@@ -2232,6 +2254,20 @@ function activeWorkspace(database, project) {
   `).get(project);
   return row ? rowToWorkspace(row) : null;
 }
+function listLineageWorkspaces(project) {
+  const database = lineageDb();
+  try {
+    seedLegacyWorkspaces(database, project);
+    return {
+      project,
+      active_workspace: activeWorkspace(database, project),
+      workspaces: listRows(database, project),
+      fetchedAt: nowIso()
+    };
+  } finally {
+    database.close();
+  }
+}
 function activeLineageWorkspaceRoot(project) {
   const database = lineageDb();
   try {
@@ -3336,27 +3372,316 @@ function importImageRerollOutput(project = defaultProject, fields) {
   }
 }
 
+// src/server/lineageSelectionPacket.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync5, statSync as statSync4 } from "node:fs";
+import { isAbsolute, resolve as resolve4 } from "node:path";
+var LineageSelectionPacketError = class extends Error {
+  constructor(message, warnings = [], errors = []) {
+    super(message);
+    this.warnings = warnings;
+    this.errors = errors;
+  }
+  warnings;
+  errors;
+};
+function listAllAssets(project) {
+  const pageSize = 100;
+  const first = listAssets(project, { page: 1, pageSize, source: "all" });
+  const assets = [...first.assets];
+  for (let page = 2; page <= first.pagination.totalPages; page += 1) {
+    assets.push(...listAssets(project, { page, pageSize, source: "all" }).assets);
+  }
+  return assets;
+}
+function resolveWorkspace(project, options) {
+  if (options.rootAssetId && options.workspaceId) {
+    throw new LineageSelectionPacketError("Use either --root or --workspace, not both.", [], ["ambiguous_workspace"]);
+  }
+  const snapshot = listLineageWorkspaces(project);
+  const target = options.workspaceId || options.rootAssetId;
+  const workspace = target ? snapshot.workspaces.find((item) => item.id === target || item.root_asset_id === target) : snapshot.active_workspace;
+  if (workspace) return workspace;
+  if (options.rootAssetId) {
+    return {
+      id: lineageWorkspaceId(project, options.rootAssetId),
+      project,
+      root_asset_id: options.rootAssetId,
+      title: `${options.rootAssetId} lineage`,
+      status: "active",
+      created_by: "system",
+      created_at: "",
+      updated_at: ""
+    };
+  }
+  const message = options.workspaceId ? `Unknown lineage workspace: ${options.workspaceId}` : "No active lineage workspace. Pass --root or activate a workspace first.";
+  throw new LineageSelectionPacketError(message, [], [options.workspaceId ? "unknown_workspace" : "missing_active_workspace"]);
+}
+function resolveLocalReference(reference) {
+  if (!reference) return void 0;
+  if (isAbsolute(reference)) return reference;
+  const repoRelative = resolve4(repoRoot, reference);
+  if (existsSync5(repoRelative)) return repoRelative;
+  return resolve4(repoRoot, ".asset-scratch", reference);
+}
+function fileSize(path) {
+  if (!path || !existsSync5(path)) return void 0;
+  try {
+    return statSync4(path).size;
+  } catch {
+    return void 0;
+  }
+}
+function storageState(hasLocal, hasS3) {
+  if (hasLocal && hasS3) return "local_and_s3";
+  if (hasLocal) return "local_only";
+  if (hasS3) return "s3_backed";
+  return "unresolved";
+}
+function currentAttemptFor(node) {
+  if (!node.current_attempt) return void 0;
+  return {
+    asset_id: node.current_attempt.asset_id,
+    checksum_sha256: node.current_attempt.checksum_sha256,
+    file_path: node.current_attempt.file_path,
+    generation_job_id: node.current_attempt.generation_job_id,
+    id: node.current_attempt.id,
+    is_current: node.current_attempt.is_current,
+    source: node.current_attempt.source
+  };
+}
+function assetForNode(node, catalogAsset, warnings) {
+  const localReference = catalogAsset?.local?.absolute_path || node.current_attempt?.file_path || node.local_path || catalogAsset?.local?.relative_path;
+  const absolutePath = catalogAsset?.local?.absolute_path || resolveLocalReference(localReference);
+  const localExists = absolutePath ? existsSync5(absolutePath) : false;
+  const hasLocalClaim = Boolean(absolutePath || node.local_path || catalogAsset?.local?.relative_path);
+  const s3Key = catalogAsset?.s3?.key || node.s3_key;
+  const hasS3 = Boolean(s3Key);
+  const checksum = catalogAsset?.local?.checksum_sha256 || node.current_attempt?.checksum_sha256 || node.checksum_sha256 || catalogAsset?.s3?.checksum_sha256;
+  const mimeType = catalogAsset?.local?.content_type || catalogAsset?.s3?.content_type;
+  const mediaType = catalogAsset?.content_type || node.media_type;
+  if (hasLocalClaim && !localExists) warnings.push(`Selected asset ${node.asset_id} has a local path but the file is missing: ${absolutePath || node.local_path}`);
+  if (!hasLocalClaim && !hasS3) warnings.push(`Selected asset ${node.asset_id} has neither a local file nor S3 key.`);
+  if (mediaType && mediaType !== "image" && mediaType !== "gif") warnings.push(`Selected asset ${node.asset_id} is ${mediaType}, not an image/gif asset.`);
+  return {
+    asset_id: node.asset_id,
+    campaign: catalogAsset?.campaign || node.campaign,
+    channel: catalogAsset?.channel || node.channel,
+    checksum_sha256: checksum,
+    current_attempt: currentAttemptFor(node),
+    local: {
+      absolute_path: absolutePath,
+      content_type: catalogAsset?.local?.content_type,
+      exists: localExists,
+      relative_path: catalogAsset?.local?.relative_path || node.local_path || node.current_attempt?.file_path,
+      size_bytes: catalogAsset?.local?.size_bytes || fileSize(absolutePath)
+    },
+    media_type: mediaType,
+    mime_type: mimeType,
+    review_notes: node.review_notes,
+    review_state: node.review_state,
+    s3: {
+      bucket: catalogAsset?.s3?.bucket,
+      checksum_sha256: catalogAsset?.s3?.checksum_sha256,
+      content_type: catalogAsset?.s3?.content_type,
+      etag: catalogAsset?.s3?.etag,
+      key: s3Key,
+      region: catalogAsset?.s3?.region,
+      size_bytes: catalogAsset?.s3?.size_bytes,
+      version_id: catalogAsset?.s3?.version_id
+    },
+    selection_note: node.selection_note,
+    source: catalogAsset?.source || node.source,
+    status: catalogAsset?.status || node.status,
+    storage_state: storageState(hasLocalClaim, hasS3),
+    title: catalogAsset?.title || node.title || node.asset_id
+  };
+}
+function packetId(packetIdentity) {
+  const digest = createHash3("sha256").update(JSON.stringify(packetIdentity)).digest("hex").slice(0, 24);
+  return `lineage_packet_${digest}`;
+}
+function getLineageSelectionPacket(project, options = {}) {
+  const workspace = resolveWorkspace(project, options);
+  const snapshot = getLineageSnapshot(project, workspace.root_asset_id);
+  const catalogSummary = validateProject(project);
+  const catalogAssets = listAllAssets(project);
+  const catalogById = new Map(catalogAssets.map((asset) => [asset.asset_id, asset]));
+  const warnings = [];
+  const errors = [];
+  const nodeById = new Map(snapshot.nodes.map((node) => [node.asset_id, node]));
+  const selectedItems = snapshot.selections.map((selection) => ({
+    asset_id: selection.asset_id,
+    position: selection.position,
+    selected_at: selection.selected_at,
+    selection_note: selection.notes
+  }));
+  if (selectedItems.length === 0) warnings.push(`Lineage workspace ${workspace.id} has no selected assets.`);
+  const assets = selectedItems.flatMap((item) => {
+    const node = nodeById.get(item.asset_id);
+    if (!node) {
+      const message = `Selected asset ${item.asset_id} is not present in the resolved workspace snapshot.`;
+      warnings.push(message);
+      errors.push("selected_asset_outside_workspace");
+      return [];
+    }
+    return [assetForNode(node, catalogById.get(item.asset_id), warnings)];
+  });
+  if (assets.some((asset) => !asset.dimensions)) warnings.push("Image dimensions are unavailable for one or more selected assets.");
+  if (options.strict) {
+    const strictErrors = [
+      ...selectedItems.length === 0 ? ["empty_selection"] : [],
+      ...assets.filter((asset) => asset.local.absolute_path && !asset.local.exists).map((asset) => `missing_local_file:${asset.asset_id}`),
+      ...errors
+    ];
+    if (strictErrors.length > 0) {
+      throw new LineageSelectionPacketError(`Lineage selection packet strict mode failed: ${strictErrors.join(", ")}`, warnings, strictErrors);
+    }
+  }
+  const context = {
+    campaign: options.campaign,
+    channel: options.channel,
+    labels: options.labels || [],
+    notes: options.contextNotes
+  };
+  const identity = {
+    assets: assets.map((asset) => ({
+      asset_id: asset.asset_id,
+      checksum_sha256: asset.checksum_sha256,
+      local_path: asset.local.absolute_path,
+      s3_key: asset.s3.key,
+      storage_state: asset.storage_state
+    })),
+    context,
+    project,
+    root_asset_id: workspace.root_asset_id,
+    schema_version: "lineage.selection_packet.v1",
+    selection: selectedItems,
+    workspace_id: workspace.id
+  };
+  return {
+    assets,
+    context,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    errors,
+    kind: "lineage.selection_packet",
+    packet_id: packetId(identity),
+    product: catalogSummary.product,
+    project,
+    schema_version: "lineage.selection_packet.v1",
+    selection: {
+      asset_ids: selectedItems.map((item) => item.asset_id),
+      count: selectedItems.length,
+      items: selectedItems,
+      root_asset_id: workspace.root_asset_id
+    },
+    source: {
+      app: "lineage",
+      command: options.command,
+      db_path: options.dbPath || process.env.LINEAGE_DB || lineageDbPath(),
+      package: options.packageVersion
+    },
+    warnings: [...new Set(warnings)],
+    workspace: {
+      active_at: workspace.active_at,
+      id: workspace.id,
+      notes: workspace.notes,
+      root_asset_id: workspace.root_asset_id,
+      status: workspace.status,
+      title: workspace.title
+    }
+  };
+}
+
+// src/server/runtimeInfo.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createRequire as createRequire2 } from "node:module";
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+var require3 = createRequire2(import.meta.url);
+function packageInfo() {
+  try {
+    const info = JSON.parse(readFileSync3(join6(repoRoot, "package.json"), "utf8"));
+    return { name: info.name || "@mean-weasel/lineage", version: info.version || "0.0.0" };
+  } catch {
+    return { name: "@mean-weasel/lineage", version: "0.0.0" };
+  }
+}
+function normalizeRuntimeChannel(value) {
+  if (value === "stable" || value === "preview" || value === "dev") return value;
+  if (value === "production") return "stable";
+  if (value === "next") return "preview";
+  if (value === "development") return "dev";
+  return process.env.NODE_ENV === "production" ? "stable" : "dev";
+}
+function gitSha() {
+  const envSha = process.env.LINEAGE_GIT_SHA || process.env.GITHUB_SHA;
+  if (envSha) return envSha.slice(0, 40);
+  if (!existsSync6(join6(repoRoot, ".git"))) return void 0;
+  const result = spawnSync2("git", ["rev-parse", "--short=12", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+  return result.status === 0 ? result.stdout.trim() || void 0 : void 0;
+}
+function tableExists(database, table) {
+  return Boolean(database.prepare("select name from sqlite_master where type = 'table' and name = ?").get(table));
+}
+function tableCount(database, table) {
+  if (!tableExists(database, table)) return void 0;
+  const row = database.prepare(`select count(*) count from ${table}`).get();
+  return typeof row?.count === "number" ? row.count : void 0;
+}
+function getLineageRuntimeInfo(options = {}) {
+  const info = packageInfo();
+  const dbPath = options.dbPath || lineageDbPath();
+  const databaseInfo = { exists: existsSync6(dbPath), path: dbPath };
+  if (databaseInfo.exists) {
+    try {
+      const stat = statSync5(dbPath);
+      databaseInfo.modified_at = stat.mtime.toISOString();
+      databaseInfo.size_bytes = stat.size;
+      const { DatabaseSync } = require3("node:sqlite");
+      const database = new DatabaseSync(dbPath, { readOnly: true });
+      try {
+        databaseInfo.projects = tableCount(database, "projects");
+        databaseInfo.workspaces = tableCount(database, "lineage_workspaces");
+      } finally {
+        database.close();
+      }
+    } catch (error) {
+      databaseInfo.error = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return {
+    channel: normalizeRuntimeChannel(options.channel || process.env.LINEAGE_CHANNEL || process.env.LINEAGE_RELEASE_CHANNEL),
+    database: databaseInfo,
+    fetchedAt: nowIso(),
+    git_sha: gitSha(),
+    node_env: process.env.NODE_ENV,
+    package_name: info.name,
+    version: info.version
+  };
+}
+
 // src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
   SIGTERM: 143
 };
 function packageRoot() {
-  return resolve4(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
+  return resolve5(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
-    const packageInfo = JSON.parse(readFileSync3(join6(packageRoot(), "package.json"), "utf8"));
-    return packageInfo.version || "0.0.0";
+    const packageInfo2 = JSON.parse(readFileSync4(join7(packageRoot(), "package.json"), "utf8"));
+    return packageInfo2.version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
 function dataRoot(displayName) {
   if (process.env.LINEAGE_HOME) return process.env.LINEAGE_HOME;
-  if (platform() === "darwin") return join6(homedir(), "Library", "Application Support", displayName);
-  if (platform() === "win32") return join6(process.env.APPDATA || join6(homedir(), "AppData", "Roaming"), displayName);
-  return join6(process.env.XDG_DATA_HOME || join6(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
+  if (platform() === "darwin") return join7(homedir(), "Library", "Application Support", displayName);
+  if (platform() === "win32") return join7(process.env.APPDATA || join7(homedir(), "AppData", "Roaming"), displayName);
+  return join7(process.env.XDG_DATA_HOME || join7(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
 }
 function readOption(args, name) {
   const prefix = `${name}=`;
@@ -3366,6 +3691,19 @@ function readOption(args, name) {
   if (index >= 0) return args[index + 1];
   return void 0;
 }
+function readOptions(args, name) {
+  const values = [];
+  const prefix = `${name}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length));
+    else if (arg === name && args[index + 1] && !args[index + 1].startsWith("--")) {
+      values.push(args[index + 1]);
+      index += 1;
+    }
+  }
+  return values;
+}
 function resolveStartOptions(config, args) {
   const runtimeDir = dataRoot(config.displayName);
   const rawPort = readOption(args, "--port") || process.env.PORT || String(config.defaultPort);
@@ -3374,7 +3712,7 @@ function resolveStartOptions(config, args) {
     throw new Error(`Invalid port: ${rawPort}`);
   }
   return {
-    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join6(runtimeDir, `${config.binName}.sqlite`),
+    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join7(runtimeDir, `${config.binName}.sqlite`),
     host: readOption(args, "--host") || process.env.HOST || config.defaultHost,
     json: args.includes("--json"),
     open: args.includes("--open"),
@@ -3389,6 +3727,7 @@ Usage:
   ${config.binName} next [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${config.binName} brief [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${config.binName} inspect --asset-id <asset-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} selection packet [--project <project>] [--workspace <id-or-root>|--root <asset-id>] [--channel <channel>] [--campaign <campaign>] [--context-notes <text>] [--label <label>] [--out <path>] [--strict] [--db <path>] [--json]
   ${config.binName} link-child --root <asset-id> --child <asset-id> [--project <project>] [--claim-token <claim-id.secret>] [--confirm-write] [--db <path>] [--json]
   ${config.binName} reroll list --root <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} reroll mark --root <asset-id> --target <asset-id> [--notes <text>] [--requested-by agent|human|system] [--project <project>] [--confirm-write] [--db <path>] [--json]
@@ -3403,6 +3742,7 @@ Usage:
   ${config.binName} tasks cancel --task <task-id> [--confirm-write] [--override] [--project <project>] [--db <path>] [--json]
   ${config.binName} tasks override --task <task-id> --reason <text> [--instructions <text>] [--project <project>] [--db <path>] [--json]
   ${config.binName} tasks instructions --task <task-id> --instructions <text> [--project <project>] [--db <path>] [--json]
+  ${config.binName} db info [--db <path>] [--json]
   ${config.binName} agent claim --project <project> --scope <scope> --target <target-id> --agent-name <name> [--channel <channel>] [--ttl 20m] [--json]
   ${config.binName} agent graph --root <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} agent status [--project <project>] [--json]
@@ -3464,6 +3804,31 @@ function runLineageDataCommand(command, args) {
     if (!options.assetId) throw new Error("lineage inspect requires --asset-id");
     return getLineageSnapshot(options.project, options.assetId);
   }
+  if (command === "selection") {
+    const subcommand = positionalArgs(args)[0] || "";
+    if (subcommand !== "packet") throw new Error(`Unknown selection command: ${subcommand}`);
+    const labels = readOptions(args, "--label").flatMap((label) => label.split(",")).map((label) => label.trim()).filter(Boolean);
+    const packet = getLineageSelectionPacket(options.project, {
+      campaign: readOption(args, "--campaign"),
+      channel: readOption(args, "--channel"),
+      command: "lineage selection packet",
+      contextNotes: readOption(args, "--context-notes") || readOption(args, "--notes"),
+      dbPath: options.dbPath,
+      labels,
+      packageVersion: packageVersion(),
+      rootAssetId: options.rootAssetId,
+      strict: args.includes("--strict"),
+      workspaceId: readOption(args, "--workspace") || readOption(args, "--workspace-id")
+    });
+    const out = readOption(args, "--out");
+    if (out) {
+      const outPath = resolve5(out);
+      mkdirSync4(dirname3(outPath), { recursive: true });
+      writeFileSync2(outPath, `${JSON.stringify(packet, null, 2)}
+`);
+    }
+    return packet;
+  }
   if (command === "link-child") {
     if (!options.childAssetId) throw new Error("lineage link-child requires --child");
     return linkSelectedLineageChild(options.project, {
@@ -3613,6 +3978,13 @@ function printDataResult(command, result, json) {
     console.log(`Active: ${snapshot.active_asset_id}`);
     return;
   }
+  if (command === "selection" && result && typeof result === "object" && "packet_id" in result) {
+    const packet = result;
+    console.log(`${packet.packet_id}: ${packet.selection?.count || packet.assets?.length || 0} selected asset(s)`);
+    if (packet.workspace?.root_asset_id) console.log(`Root: ${packet.workspace.root_asset_id}`);
+    for (const warning of packet.warnings || []) console.log(`Warning: ${warning}`);
+    return;
+  }
   if (command === "link-child" && result && typeof result === "object") {
     const link = result;
     console.log(link.message || `${link.dryRun ? "Dry run: " : ""}Link ${link.edge?.child_asset_id || "child"} from ${link.edge?.parent_asset_id || "parent"}`);
@@ -3655,6 +4027,34 @@ function printDataResult(command, result, json) {
   }
   console.log(String(result));
 }
+function runLineageDbCommand(config, command, args) {
+  const dbPath = readOption(args, "--db");
+  if (dbPath) process.env.LINEAGE_DB = dbPath;
+  if (command === "info") return getLineageRuntimeInfo({ channel: config.channel, dbPath });
+  throw new Error(`Unknown db command: ${command}`);
+}
+function printDbResult(command, result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (command === "info" && result && typeof result === "object" && "database" in result) {
+    const runtime = result;
+    console.log(`Channel: ${runtime.channel}`);
+    console.log(`Version: ${runtime.version}`);
+    if (runtime.git_sha) console.log(`Git: ${runtime.git_sha}`);
+    if (runtime.node_env) console.log(`Node env: ${runtime.node_env}`);
+    console.log(`SQLite: ${runtime.database.path}`);
+    console.log(`Exists: ${runtime.database.exists ? "yes" : "no"}`);
+    if (runtime.database.size_bytes !== void 0) console.log(`Size: ${runtime.database.size_bytes} bytes`);
+    if (runtime.database.modified_at) console.log(`Modified: ${runtime.database.modified_at}`);
+    if (runtime.database.projects !== void 0) console.log(`Projects: ${runtime.database.projects}`);
+    if (runtime.database.workspaces !== void 0) console.log(`Workspaces: ${runtime.database.workspaces}`);
+    if (runtime.database.error) console.log(`Warning: ${runtime.database.error}`);
+    return;
+  }
+  console.log(String(result));
+}
 function runLineageAgentCommand(command, args) {
   const dbPath = readOption(args, "--db");
   if (dbPath) process.env.LINEAGE_DB = dbPath;
@@ -3781,8 +4181,8 @@ function start(config, args) {
     else console.error(`${config.binName}: ${message}`);
     process.exit(1);
   }
-  const serverPath = join6(packageRoot(), "dist", "server.js");
-  if (!existsSync5(serverPath)) {
+  const serverPath = join7(packageRoot(), "dist", "server.js");
+  if (!existsSync7(serverPath)) {
     const message = `Missing bundled server at ${serverPath}. Run npm run build before using ${config.binName} start from a source checkout.`;
     if (options.json) console.error(JSON.stringify({ ok: false, error: message }, null, 2));
     else console.error(`${config.binName}: ${message}`);
@@ -3836,7 +4236,7 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     start(config, normalizedArgs.slice(1));
     return;
   }
-  if (command === "next" || command === "brief" || command === "inspect" || command === "link-child" || command === "reroll" || command === "tasks") {
+  if (command === "next" || command === "brief" || command === "inspect" || command === "selection" || command === "link-child" || command === "reroll" || command === "tasks") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {
@@ -3851,6 +4251,20 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     }
     process.exit(0);
   }
+  if (command === "db") {
+    const commandArgs = normalizedArgs.slice(2);
+    const dbCommand = normalizedArgs[1] || "";
+    const json2 = commandArgs.includes("--json");
+    try {
+      printDbResult(dbCommand, runLineageDbCommand(config, dbCommand, commandArgs), json2);
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      if (json2) console.error(JSON.stringify({ ok: false, command: `db ${dbCommand}`, error: message2 }, null, 2));
+      else console.error(`${config.binName}: ${message2}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
   if (command === "agent") {
     const commandArgs = normalizedArgs.slice(2);
     const agentCommand = normalizedArgs[1] || "";