@mean-weasel/lineage 0.1.1 → 0.1.2

package/dist/cli/lineage-dev.js

@@ -1,21 +1,1199 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname as dirname3, join as join5, resolve as resolve3 } from "node:path";
 import { spawn } from "node:child_process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/server/assetCore.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+
+// src/server/adapters/storage/s3StorageAdapter.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync, statSync as statSync2 } from "node:fs";
+import { basename as basename2, dirname, join as join2 } from "node:path";
+
+// src/server/localReview.ts
+import { createHash } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, extname, join, relative, resolve } from "node:path";
+var mimeByExt = {
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".mov": "video/quicktime",
+  ".mp4": "video/mp4",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp"
+};
+var localReviewExts = new Set(Object.keys(mimeByExt));
+function contentTypeFor(file) {
+  return mimeByExt[extname(file).toLowerCase()] || "application/octet-stream";
+}
+function fileSha256(file) {
+  return createHash("sha256").update(readFileSync(file)).digest("hex");
+}
+
+// src/server/adapters/storage/s3StorageAdapter.ts
+function parseAssetIdFromS3Key(key) {
+  const marker = "/assets/";
+  const index = key.indexOf(marker);
+  if (index === -1) return void 0;
+  return key.slice(index + marker.length).split("/")[0];
+}
+function previewDataUrl(asset) {
+  const title = asset.title || asset.asset_id;
+  const label = `${asset.channel || "catalog"} / ${asset.status || "working"}`;
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="675" viewBox="0 0 1200 675"><rect width="1200" height="675" fill="#f7f5ef"/><rect x="56" y="56" width="1088" height="563" rx="18" fill="#10201c"/><text x="96" y="145" fill="#9fe6c8" font-family="Arial, sans-serif" font-size="34" font-weight="700">Lineage catalog preview</text><text x="96" y="230" fill="#fff8e6" font-family="Arial, sans-serif" font-size="56" font-weight="700">${escapeSvgText(asset.asset_id)}</text><text x="96" y="330" fill="#d9e8df" font-family="Arial, sans-serif" font-size="34">${escapeSvgText(title)}</text><text x="96" y="500" fill="#9fb7ae" font-family="Arial, sans-serif" font-size="26">${escapeSvgText(label)}. No external storage requested.</text></svg>`;
+  return `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+}
+function escapeSvgText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function createS3StorageAdapter(deps) {
+  return {
+    deleteObjectGuarded(project, assetId, confirmation) {
+      const enabled = process.env.LINEAGE_ENABLE_CLOUD_DELETE === "true";
+      if (!enabled) {
+        throw deps.createError("S3 delete is disabled. Use archive unless a human enables LINEAGE_ENABLE_CLOUD_DELETE.", 403);
+      }
+      if (confirmation !== `delete ${assetId}`) {
+        throw deps.createError(`Delete confirmation must exactly equal: delete ${assetId}`);
+      }
+      const catalog = deps.loadCatalog(project);
+      const asset = deps.assetById(catalog, assetId);
+      if (!asset.s3) throw deps.createError(`Asset has no S3 object: ${assetId}`);
+      deps.runAws(["s3api", "delete-object", "--bucket", asset.s3.bucket, "--key", asset.s3.key, "--region", asset.s3.region]);
+      asset.status = "archived";
+      deps.saveCatalog(project, catalog);
+      return { ok: true, message: `Deleted current S3 object and archived ${assetId}`, catalog };
+    },
+    getIdentity() {
+      try {
+        const output = deps.runAws(["sts", "get-caller-identity", "--query", "{Account:Account,Arn:Arn}", "--output", "json"]);
+        const parsed = JSON.parse(output.stdout);
+        return { account: parsed.Account, arn: parsed.Arn };
+      } catch {
+        return void 0;
+      }
+    },
+    listLiveObjects(catalog) {
+      const bucket = catalog.default_bucket;
+      const region = catalog.default_region;
+      const prefix = `products/${catalog.product}/`;
+      const output = deps.runAws(["s3api", "list-objects-v2", "--bucket", bucket, "--prefix", prefix, "--region", region, "--output", "json"]);
+      const parsed = JSON.parse(output.stdout);
+      const catalogKeys = new Set(catalog.assets.map((asset) => asset.s3?.key).filter(Boolean));
+      return (parsed.Contents || []).map((item) => ({
+        key: item.Key,
+        size: item.Size,
+        lastModified: item.LastModified,
+        storageClass: item.StorageClass,
+        cataloged: catalogKeys.has(item.Key),
+        assetId: parseAssetIdFromS3Key(item.Key)
+      }));
+    },
+    presignAsset(project, assetId, expiresIn = 900) {
+      const catalog = deps.loadCatalog(project);
+      const asset = deps.assetById(catalog, assetId);
+      return { assetId, expiresIn, url: previewDataUrl(asset) };
+    },
+    promoteAsset(project, assetId, confirmWrite) {
+      if (!confirmWrite) throw deps.createError("Promote requires confirmWrite=true");
+      const catalog = deps.loadCatalog(project);
+      const asset = deps.assetById(catalog, assetId);
+      asset.status = "published";
+      deps.saveCatalog(project, catalog);
+      return {
+        ok: true,
+        message: `Promoted ${assetId}`,
+        catalog
+      };
+    },
+    pullAsset(project, assetId, out = ".asset-scratch") {
+      const catalog = deps.loadCatalog(project);
+      const asset = deps.assetById(catalog, assetId);
+      return {
+        ok: true,
+        message: `Prepared ${assetId} for local review`,
+        output: {
+          assetId: asset.asset_id,
+          out,
+          storage: asset.local ? "local" : asset.s3 ? "catalog-s3-metadata" : "catalog",
+          note: "Lineage public package does not pull cloud objects automatically."
+        }
+      };
+    },
+    uploadAsset(file, fields) {
+      if (!fields.confirmWrite) throw deps.createError("Upload requires confirmWrite=true");
+      if (!existsSync2(file)) throw deps.createError(`Upload file missing: ${file}`, 404);
+      if (!["working", "published"].includes(fields.status)) throw deps.createError("Upload status must be working or published");
+      if (!deps.supportedContentTypes.has(fields.type)) throw deps.createError(`Unsupported asset type: ${fields.type}`);
+      const project = deps.cleanProject(fields.project || fields.product || deps.defaultProject);
+      const catalog = deps.loadCatalog(project);
+      const relativePath = join2("uploads", project, fields.assetId, basename2(file));
+      const absolutePath = join2(deps.repoRoot, ".asset-scratch", relativePath);
+      mkdirSync(dirname(absolutePath), { recursive: true });
+      copyFileSync(file, absolutePath);
+      const stats = statSync2(absolutePath);
+      const contentType = contentTypeFor(absolutePath);
+      const checksumSha256 = fileSha256(absolutePath);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const nextAsset = {
+        asset_id: fields.assetId,
+        audience: fields.audience,
+        campaign: fields.campaign,
+        channel: fields.channel,
+        content_type: fields.type,
+        cta: fields.cta,
+        hook: fields.hook,
+        ...fields.format ? { format: fields.format } : {},
+        local: {
+          absolute_path: absolutePath,
+          checksum_sha256: checksumSha256,
+          content_type: contentType,
+          relative_path: relativePath,
+          size_bytes: stats.size,
+          updated_at: now
+        },
+        ...fields.messageFamily ? { message_family: fields.messageFamily } : {},
+        ...fields.notes ? { notes: fields.notes } : {},
+        product: project,
+        project,
+        source: "catalog",
+        status: fields.status,
+        title: fields.title,
+        utm_content: fields.utmContent
+      };
+      const existing = catalog.assets.findIndex((asset) => asset.asset_id === fields.assetId);
+      if (existing >= 0) catalog.assets[existing] = { ...catalog.assets[existing], ...nextAsset };
+      else catalog.assets.push(nextAsset);
+      deps.saveCatalog(project, catalog);
+      return {
+        ok: true,
+        message: `Recorded ${fields.assetId} locally`,
+        output: {
+          file: basename2(absolutePath),
+          relativePath,
+          sizeBytes: stats.size,
+          contentType,
+          checksumSha256
+        },
+        catalog
+      };
+    }
+  };
+}
+
+// src/server/assetLineageDb.ts
+import { createRequire } from "node:module";
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var require2 = createRequire(import.meta.url);
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function lineageDbPath() {
+  return process.env.LINEAGE_DB || join3(repoRoot, ".lineage", "asset-lineage.sqlite");
+}
+function lineageDb() {
+  mkdirSync2(join3(lineageDbPath(), ".."), { recursive: true });
+  const { DatabaseSync } = require2("node:sqlite");
+  const database = new DatabaseSync(lineageDbPath());
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA busy_timeout = 5000");
+  database.exec(`
+    create table if not exists projects (
+      id text primary key,
+      product text not null,
+      catalog_path text,
+      created_at text not null,
+      updated_at text not null
+    );
+    create table if not exists assets (
+      id text primary key,
+      project_id text not null references projects(id),
+      source text not null check (source in ('local', 'catalog')),
+      local_path text,
+      s3_key text,
+      checksum_sha256 text,
+      media_type text not null,
+      title text not null,
+      status text not null,
+      channel text,
+      campaign text,
+      audience text,
+      size_bytes integer,
+      content_type text,
+      created_at text not null,
+      updated_at text not null,
+      last_seen_at text not null
+    );
+    create index if not exists assets_project_source_seen on assets(project_id, source, last_seen_at);
+    create index if not exists assets_project_checksum on assets(project_id, checksum_sha256);
+    create index if not exists assets_project_channel_campaign on assets(project_id, channel, campaign);
+    create table if not exists asset_edges (
+      id text primary key,
+      project_id text not null references projects(id),
+      parent_asset_id text not null references assets(id),
+      child_asset_id text not null references assets(id),
+      relation_type text not null check (relation_type in ('derived_from')),
+      created_at text not null,
+      unique (project_id, parent_asset_id, child_asset_id, relation_type)
+    );
+    create index if not exists edges_parent on asset_edges(project_id, parent_asset_id);
+    create index if not exists edges_child on asset_edges(project_id, child_asset_id);
+    create table if not exists asset_reviews (
+      asset_id text primary key references assets(id),
+      review_state text not null check (review_state in ('unreviewed', 'approved', 'needs_revision', 'rejected', 'ignored')),
+      reviewed_at text,
+      ignored_at text,
+      notes text,
+      updated_at text not null
+    );
+    create table if not exists asset_selections (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      asset_id text not null references assets(id),
+      notes text,
+      selected_at text not null,
+      unique(project_id, root_asset_id)
+    );
+    create table if not exists asset_layouts (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      asset_id text not null references assets(id),
+      x real not null,
+      y real not null,
+      updated_at text not null,
+      unique(project_id, root_asset_id, asset_id)
+    );
+    create table if not exists lineage_workspaces (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      title text not null,
+      status text not null check (status in ('active', 'paused', 'archived')),
+      notes text,
+      created_by text not null check (created_by in ('human', 'agent', 'system')),
+      active_at text,
+      created_at text not null,
+      updated_at text not null,
+      unique(project_id, root_asset_id)
+    );
+    create index if not exists lineage_workspaces_project_status on lineage_workspaces(project_id, status, updated_at);
+    create index if not exists lineage_workspaces_project_active on lineage_workspaces(project_id, active_at);
+    create table if not exists asset_ledger_records (
+      id text primary key,
+      project_id text not null references projects(id),
+      canonical_asset_id text not null,
+      checksum_sha256 text,
+      media_type text not null,
+      title text not null,
+      status text not null,
+      channel text,
+      campaign text,
+      audience text,
+      created_at text not null,
+      updated_at text not null,
+      first_seen_at text not null default (datetime('now')),
+      last_seen_at text not null
+    );
+    create index if not exists asset_ledger_records_project_seen on asset_ledger_records(project_id, last_seen_at);
+    create index if not exists asset_ledger_records_project_checksum on asset_ledger_records(project_id, checksum_sha256);
+    create table if not exists asset_ledger_sources (
+      id text primary key,
+      project_id text not null references projects(id),
+      record_id text not null references asset_ledger_records(id) on delete cascade,
+      source_type text not null check (source_type in ('local', 'catalog', 's3')),
+      asset_id text,
+      local_path text,
+      s3_bucket text,
+      s3_region text,
+      s3_key text,
+      s3_version_id text,
+      etag text,
+      size_bytes integer,
+      content_type text,
+      updated_at text,
+      first_seen_at text not null default (datetime('now')),
+      last_seen_at text not null
+    );
+    create index if not exists asset_ledger_sources_project_type on asset_ledger_sources(project_id, source_type);
+    create index if not exists asset_ledger_sources_record on asset_ledger_sources(project_id, record_id);
+    create index if not exists asset_ledger_sources_s3_key on asset_ledger_sources(project_id, s3_key);
+    create table if not exists asset_ledger_placements (
+      id text primary key,
+      project_id text not null references projects(id),
+      asset_id text not null,
+      channel text not null,
+      status text not null,
+      scheduled_at text,
+      posted_at text,
+      url text,
+      notes text,
+      updated_at text not null,
+      synced_at text not null,
+      unique(project_id, asset_id, channel)
+    );
+    create index if not exists asset_ledger_placements_project_status on asset_ledger_placements(project_id, status);
+    create index if not exists asset_ledger_placements_asset on asset_ledger_placements(project_id, asset_id);
+    create table if not exists asset_ledger_index_runs (
+      id text primary key,
+      project_id text not null references projects(id),
+      source_mode text not null check (source_mode in ('all', 'catalog', 'local')),
+      include_live_s3 integer not null default 0,
+      status text not null check (status in ('running', 'complete', 'failed')),
+      started_at text not null,
+      completed_at text,
+      assets_indexed integer not null default 0,
+      records_after integer not null default 0,
+      catalog_sources_after integer not null default 0,
+      local_sources_after integer not null default 0,
+      s3_sources_after integer not null default 0,
+      error text
+    );
+    create index if not exists asset_ledger_index_runs_project_started on asset_ledger_index_runs(project_id, started_at);
+    create table if not exists content_batches (
+      id text not null,
+      project_id text not null references projects(id),
+      title text not null,
+      campaign text,
+      channel text,
+      status text not null check (status in ('active', 'archived')),
+      notes text,
+      created_at text not null,
+      updated_at text not null,
+      primary key(project_id, id)
+    );
+    create index if not exists content_batches_project_updated on content_batches(project_id, updated_at);
+    create table if not exists content_posts (
+      id text not null,
+      project_id text not null references projects(id),
+      batch_id text not null,
+      channel text not null,
+      title text not null,
+      phase text not null check (phase in ('draft', 'review', 'scheduled', 'posted', 'skipped', 'archived')),
+      campaign text,
+      body text,
+      cta text,
+      scheduled_at text,
+      posted_at text,
+      url text,
+      notes text,
+      source_path text,
+      created_at text not null,
+      updated_at text not null,
+      primary key(project_id, id),
+      foreign key(project_id, batch_id) references content_batches(project_id, id) on delete cascade
+    );
+    create index if not exists content_posts_project_phase on content_posts(project_id, phase);
+    create index if not exists content_posts_batch on content_posts(project_id, batch_id);
+    create table if not exists content_post_assets (
+      id text primary key,
+      project_id text not null references projects(id),
+      post_id text not null,
+      asset_id text not null,
+      role text not null,
+      notes text,
+      attached_at text not null,
+      unique(project_id, post_id, asset_id, role),
+      foreign key(project_id, post_id) references content_posts(project_id, id) on delete cascade
+    );
+    create index if not exists content_post_assets_post on content_post_assets(project_id, post_id);
+    create index if not exists content_post_assets_asset on content_post_assets(project_id, asset_id);
+    create table if not exists content_targets (
+      project_id text primary key references projects(id),
+      post_id text not null,
+      notes text,
+      selected_at text not null,
+      updated_at text not null,
+      foreign key(project_id, post_id) references content_posts(project_id, id) on delete cascade
+    );
+    create table if not exists selection_sets (
+      id text primary key,
+      project_id text not null references projects(id),
+      kind text not null check (kind in ('current', 'review')),
+      key text not null,
+      label text not null,
+      status text not null check (status in ('active', 'archived')),
+      created_by text not null check (created_by in ('human', 'agent', 'system')),
+      created_at text not null,
+      updated_at text not null,
+      unique(project_id, kind, key)
+    );
+    create index if not exists selection_sets_project_kind on selection_sets(project_id, kind, updated_at);
+    create table if not exists selection_items (
+      id text primary key,
+      set_id text not null references selection_sets(id) on delete cascade,
+      asset_id text not null,
+      role text not null check (role in ('primary', 'candidate', 'next_base')),
+      variation_label text,
+      position integer not null default 0,
+      selected_by text check (selected_by in ('human', 'agent', 'system')),
+      selected_at text,
+      deselected_at text,
+      notes text,
+      created_at text not null,
+      updated_at text not null,
+      unique(set_id, asset_id)
+    );
+    create index if not exists selection_items_set_position on selection_items(set_id, position);
+    create unique index if not exists selection_items_set_label on selection_items(set_id, variation_label) where variation_label is not null;
+    create table if not exists generation_jobs (
+      id text primary key,
+      project_id text not null references projects(id),
+      provider text not null default 'codex-handoff',
+      adapter_version text not null,
+      source_mode text not null check (source_mode in ('lineage_selection')),
+      root_asset_id text not null references assets(id),
+      prompt text not null,
+      expected_output_count integer not null check (expected_output_count > 0),
+      status text not null check (status in ('planned', 'imported', 'failed', 'cancelled')),
+      output_dir text,
+      handoff_json text,
+      created_at text not null,
+      updated_at text not null,
+      imported_at text
+    );
+    create index if not exists generation_jobs_project_created on generation_jobs(project_id, created_at);
+    create table if not exists generation_job_inputs (
+      id text primary key,
+      job_id text not null references generation_jobs(id) on delete cascade,
+      project_id text not null references projects(id),
+      asset_id text not null references assets(id),
+      root_asset_id text not null references assets(id),
+      role text not null check (role in ('lineage_next_base', 'reference')),
+      position integer not null,
+      selection_strategy text not null,
+      selection_snapshot_json text not null,
+      unique(job_id, asset_id, role)
+    );
+    create index if not exists generation_job_inputs_job on generation_job_inputs(job_id, position);
+    create table if not exists generation_job_outputs (
+      id text primary key,
+      job_id text not null references generation_jobs(id) on delete cascade,
+      project_id text not null references projects(id),
+      output_index integer not null,
+      file_path text not null,
+      checksum_sha256 text not null,
+      size_bytes integer not null,
+      content_type text not null,
+      imported_asset_id text not null references assets(id),
+      parent_asset_id text not null references assets(id),
+      imported_at text not null,
+      unique(job_id, output_index),
+      unique(job_id, file_path)
+    );
+    create index if not exists generation_job_outputs_job on generation_job_outputs(job_id, output_index);
+    create table if not exists generation_job_receipts (
+      id text primary key,
+      job_id text not null references generation_jobs(id) on delete cascade,
+      receipt_type text not null check (receipt_type in ('plan', 'import', 'error')),
+      status text not null check (status in ('ok', 'error')),
+      command text not null,
+      payload_json text not null,
+      created_at text not null
+    );
+    create index if not exists generation_job_receipts_job on generation_job_receipts(job_id, created_at);
+    create table if not exists adapter_settings (project_id text not null references projects(id), adapter_type text not null check (adapter_type in ('cloud', 'scheduler', 'image_generator')), provider text not null, enabled integer not null check (enabled in (0, 1)), secret_ref text, safe_config_json text not null, created_at text not null, updated_at text not null, primary key(project_id, adapter_type, provider)); create index if not exists adapter_settings_project_type on adapter_settings(project_id, adapter_type);
+  `);
+  migrateAssetSelections(database);
+  dropLegacyAssetSelectionRootUnique(database);
+  ensureColumn(database, "asset_selections", "notes", "text");
+  ensureColumn(database, "asset_ledger_records", "first_seen_at", "text");
+  ensureColumn(database, "asset_ledger_records", "indexed_by_run_id", "text");
+  ensureColumn(database, "asset_ledger_sources", "first_seen_at", "text");
+  ensureColumn(database, "asset_ledger_sources", "indexed_by_run_id", "text");
+  ensureReviewStateValues(database);
+  return database;
+}
+function ensureColumn(database, table, column, definition) {
+  const rows = database.prepare(`pragma table_info(${table})`).all();
+  if (!rows.some((row) => row.name === column)) database.exec(`alter table ${table} add column ${column} ${definition}`);
+}
+function migrateAssetSelections(database) {
+  const rows = database.prepare("pragma table_info(asset_selections)").all();
+  if (rows.some((row) => row.name === "position")) return;
+  const notesSelect = rows.some((row) => row.name === "notes") ? "notes" : "null";
+  database.exec(`
+    create table if not exists asset_selections_v2 (
+      id text primary key,
+      project_id text not null references projects(id),
+      root_asset_id text not null references assets(id),
+      asset_id text not null references assets(id),
+      position integer not null default 0,
+      notes text,
+      selected_at text not null,
+      unique(project_id, root_asset_id, asset_id)
+    );
+    insert or ignore into asset_selections_v2 (id, project_id, root_asset_id, asset_id, position, notes, selected_at)
+      select
+        project_id || ':' || root_asset_id || ':selected:' || asset_id,
+        project_id,
+        root_asset_id,
+        asset_id,
+        0,
+        ${notesSelect},
+        selected_at
+      from asset_selections;
+    drop table asset_selections;
+    alter table asset_selections_v2 rename to asset_selections;
+    create index if not exists asset_selections_project_root_position
+      on asset_selections(project_id, root_asset_id, position, selected_at);
+  `);
+}
+function dropLegacyAssetSelectionRootUnique(database) {
+  const indexes = database.prepare("pragma index_list(asset_selections)").all();
+  for (const index of indexes) {
+    if (!index.unique) continue;
+    const columns = database.prepare(`pragma index_info(${index.name})`).all();
+    const columnNames = columns.map((column) => column.name).join(",");
+    if (columnNames === "project_id,root_asset_id") database.exec(`drop index if exists ${index.name}`);
+  }
+}
+function ensureReviewStateValues(database) {
+  const createSql = database.prepare("select sql from sqlite_master where type = 'table' and name = 'asset_reviews'").get();
+  if (createSql?.sql?.includes("needs_revision")) return;
+  database.exec(`
+    alter table asset_reviews rename to asset_reviews_old;
+    create table asset_reviews (
+      asset_id text primary key references assets(id),
+      review_state text not null check (review_state in ('unreviewed', 'approved', 'needs_revision', 'rejected', 'ignored')),
+      reviewed_at text,
+      ignored_at text,
+      notes text,
+      updated_at text not null
+    );
+    insert into asset_reviews (asset_id, review_state, reviewed_at, ignored_at, notes, updated_at)
+    select asset_id, review_state, reviewed_at, ignored_at, notes, updated_at
+    from asset_reviews_old;
+    drop table asset_reviews_old;
+  `);
+}
+
+// src/server/assetCore.ts
+function isPackageRoot(path) {
+  const packageJson = join4(path, "package.json");
+  if (!existsSync3(packageJson)) return false;
+  try {
+    const packageInfo = JSON.parse(readFileSync2(packageJson, "utf8"));
+    return packageInfo.name === "@mean-weasel/lineage";
+  } catch {
+    return false;
+  }
+}
+function resolveRepoRoot() {
+  const moduleDir = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    process.env.LINEAGE_REPO_ROOT,
+    resolve2(moduleDir, ".."),
+    resolve2(moduleDir, "../.."),
+    process.cwd()
+  ].filter((candidate) => Boolean(candidate));
+  const root = candidates.find(isPackageRoot);
+  if (!root) throw new Error("Unable to locate Lineage package root");
+  return root;
+}
+var repoRoot = resolveRepoRoot();
+var defaultProject = "demo-project";
+var defaultProduct = process.env.LINEAGE_DEFAULT_PRODUCT || defaultProject;
+var publicFallbackBucket = "lineage-demo-assets";
+var publicFallbackRegion = "us-east-1";
+var contentTypes = /* @__PURE__ */ new Set(["image", "video", "gif", "audio", "doc", "other"]);
+var projectNamePattern = /^[a-z0-9][a-z0-9-]*$/;
+var LineageAssetError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function cleanProject(project = defaultProject) {
+  if (!projectNamePattern.test(project)) {
+    throw new LineageAssetError("Project must be lowercase kebab-case");
+  }
+  return project;
+}
+function catalogPath(project = defaultProject) {
+  return join4(repoRoot, cleanProject(project), "assets", "catalog.json");
+}
+function fixtureCatalogPath(project = defaultProject) {
+  return join4(repoRoot, "fixtures", cleanProject(project), "assets", "catalog.json");
+}
+function normalizeCatalog(catalog, fallbackProject = defaultProject) {
+  const project = cleanProject(catalog.project || catalog.product || fallbackProject);
+  const product = catalog.product || project;
+  return {
+    ...catalog,
+    project,
+    product,
+    default_bucket: catalog.default_bucket || "",
+    default_region: catalog.default_region || "",
+    assets: (catalog.assets || []).map((asset) => ({
+      ...asset,
+      source: asset.source || "catalog",
+      project: asset.project || asset.product || project,
+      product: asset.product || asset.project || project
+    }))
+  };
+}
+function fallbackS3(assetId, channel, status = "working") {
+  return {
+    bucket: publicFallbackBucket,
+    checksum_sha256: void 0,
+    content_type: "image/png",
+    key: `products/${defaultProject}/campaigns/2026-06-public-demo/channels/${channel}/audiences/creators/statuses/${status}/types/image/assets/${assetId}/${assetId}.png`,
+    region: publicFallbackRegion,
+    size_bytes: 2048,
+    updated_at: "2026-06-24T12:00:00.000Z",
+    version_id: "public-demo-version"
+  };
+}
+function fallbackAsset(fields) {
+  return {
+    audience: fields.audience || "creators",
+    campaign: fields.campaign || "2026-06-public-demo",
+    content_type: "image",
+    cta: fields.cta || "Save the idea",
+    hook: fields.hook || "Public demo creative for local review.",
+    product: defaultProject,
+    project: defaultProject,
+    source: "catalog",
+    utm_content: fields.utm_content || fields.asset_id.replace(/-/g, "_"),
+    ...fields
+  };
+}
+function defaultFallbackCatalog() {
+  return normalizeCatalog({
+    assets: [
+      fallbackAsset({
+        asset_id: "demo-meta-short-form-upload-demo-post-static",
+        channel: "meta",
+        s3: fallbackS3("demo-meta-short-form-upload-demo-post-static", "meta"),
+        status: "working",
+        title: "Meta short-form demo post static"
+      }),
+      fallbackAsset({
+        asset_id: "demo-linkedin-ledger-catalog-shared",
+        channel: "linkedin",
+        hook: "Shared ledger creative with catalog metadata.",
+        s3: fallbackS3("demo-linkedin-ledger-catalog-shared", "linkedin"),
+        status: "working",
+        title: "LinkedIn ledger catalog shared"
+      }),
+      fallbackAsset({
+        asset_id: "demo-linkedin-upload-demo-done-static-grounded-v2",
+        channel: "linkedin",
+        placements: [{
+          channel: "linkedin",
+          notes: "Synthetic public scheduled placement.",
+          scheduled_at: "2026-06-24T16:00:00-07:00",
+          status: "scheduled",
+          updated_at: "2026-06-24T12:30:00.000Z"
+        }],
+        s3: fallbackS3("demo-linkedin-upload-demo-done-static-grounded-v2", "linkedin", "approved"),
+        status: "approved",
+        title: "LinkedIn upload demo scheduled static"
+      }),
+      fallbackAsset({
+        asset_id: "demo-tiktok-upload-demo-export-vertical",
+        channel: "tiktok",
+        format: "vertical",
+        hook: "Fast vertical demo export for content queue tests.",
+        s3: fallbackS3("demo-tiktok-upload-demo-export-vertical", "tiktok"),
+        status: "working",
+        title: "TikTok upload demo export vertical"
+      }),
+      fallbackAsset({
+        asset_id: "demo-youtube-short-demo-posted-cut",
+        channel: "youtube",
+        placements: [{
+          channel: "youtube",
+          notes: "Synthetic public posted placement.",
+          posted_at: "2026-06-25T16:00:00-07:00",
+          status: "posted",
+          updated_at: "2026-06-25T17:00:00.000Z"
+        }],
+        s3: fallbackS3("demo-youtube-short-demo-posted-cut", "youtube", "published"),
+        status: "published",
+        title: "YouTube short demo posted cut"
+      }),
+      fallbackAsset({
+        asset_id: "demo-x-twitter-carousel-demo-working-static",
+        channel: "x-twitter",
+        format: "static",
+        s3: fallbackS3("demo-x-twitter-carousel-demo-working-static", "x-twitter"),
+        status: "working",
+        title: "X Twitter carousel demo working static"
+      })
+    ],
+    default_bucket: "",
+    default_region: "",
+    product: defaultProject,
+    project: defaultProject
+  }, defaultProject);
+}
+function loadCatalog(project = defaultProject) {
+  const path = catalogPath(project);
+  if (existsSync3(path)) {
+    try {
+      return normalizeCatalog(JSON.parse(readFileSync2(path, "utf8")), project);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        throw new LineageAssetError(`Missing catalog: ${path}`, 404);
+      }
+      throw error;
+    }
+  }
+  const clean = cleanProject(project);
+  if (clean === defaultProject) {
+    const fixturePath = fixtureCatalogPath(clean);
+    if (existsSync3(fixturePath)) {
+      return normalizeCatalog(JSON.parse(readFileSync2(fixturePath, "utf8")), project);
+    }
+    return defaultFallbackCatalog();
+  }
+  throw new LineageAssetError(`Missing catalog: ${path}`, 404);
+}
+function saveCatalog(project, catalog) {
+  const normalized = normalizeCatalog(catalog, project);
+  mkdirSync3(dirname2(catalogPath(project)), { recursive: true });
+  writeFileSync(catalogPath(project), `${JSON.stringify(normalized, null, 2)}
+`);
+  return normalized;
+}
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    cwd: repoRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    env: {
+      ...process.env,
+      AWS_REGION: process.env.AWS_REGION || "us-east-1",
+      AWS_DEFAULT_REGION: process.env.AWS_DEFAULT_REGION || "us-east-1"
+    }
+  });
+  if (result.status !== 0) {
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw new LineageAssetError(`${command} ${args.join(" ")} failed${detail ? `: ${detail}` : ""}`, 502);
+  }
+  return { stdout: result.stdout, stderr: result.stderr };
+}
+function runAws(args) {
+  return run("aws", args);
+}
+function assetById(catalog, assetId) {
+  const asset = catalog.assets.find((item) => item.asset_id === assetId);
+  if (!asset) throw new LineageAssetError(`Unknown asset: ${assetId}`, 404);
+  return asset;
+}
+var storageAdapter = createS3StorageAdapter({
+  assetById,
+  cleanProject,
+  createError: (message, status) => new LineageAssetError(message, status),
+  defaultProject,
+  loadCatalog,
+  runAws,
+  repoRoot,
+  saveCatalog,
+  supportedContentTypes: contentTypes
+});
+
+// src/server/assetLineageSelection.ts
+function selectedRows(database, project, root) {
+  return database.prepare(`
+    select asset_id, notes, position, selected_at
+    from asset_selections
+    where project_id = ? and root_asset_id = ?
+    order by position, selected_at, asset_id
+  `).all(project, root);
+}
+
+// src/server/assetLineageWorkspaces.ts
+function lineageWorkspaceId(project, rootAssetId) {
+  return `${project}:lineage-workspace:${rootAssetId}`;
+}
+function ensureProject(database, project) {
+  const timestamp = nowIso();
+  database.prepare(`
+    insert into projects (id, product, created_at, updated_at)
+    values (?, ?, ?, ?)
+    on conflict(id) do update set product = excluded.product, updated_at = excluded.updated_at
+  `).run(project, project, timestamp, timestamp);
+}
+function rowToWorkspace(row) {
+  return {
+    id: String(row.id),
+    project: String(row.project_id),
+    root_asset_id: String(row.root_asset_id),
+    title: String(row.title),
+    status: String(row.status),
+    notes: typeof row.notes === "string" ? row.notes : void 0,
+    created_by: String(row.created_by),
+    active_at: typeof row.active_at === "string" ? row.active_at : void 0,
+    created_at: String(row.created_at),
+    updated_at: String(row.updated_at)
+  };
+}
+function knownRoots(database, project) {
+  const rows = database.prepare(`
+    select root_asset_id, max(selected_at) selected_at from asset_selections where project_id = ? group by root_asset_id
+    union
+    select root_asset_id, null selected_at from asset_layouts where project_id = ? group by root_asset_id
+    union
+    select parent_asset_id root_asset_id, null selected_at
+    from asset_edges
+    where project_id = ?
+      and parent_asset_id not in (select child_asset_id from asset_edges where project_id = ?)
+    group by parent_asset_id
+  `).all(project, project, project, project);
+  return rows.map((row) => ({ root_asset_id: row.root_asset_id, selected_at: row.selected_at || void 0 }));
+}
+function seedLegacyWorkspaces(database, project) {
+  ensureProject(database, project);
+  const timestamp = nowIso();
+  const statement = database.prepare(`
+    insert into lineage_workspaces (
+      id, project_id, root_asset_id, title, status, notes, created_by, active_at, created_at, updated_at
+    )
+    select ?, ?, a.id, a.title || ' lineage', 'active', null, 'system', ?, ?, ?
+    from assets a
+    where a.project_id = ? and a.id = ?
+    on conflict(project_id, root_asset_id) do nothing
+  `);
+  for (const root of knownRoots(database, project)) {
+    statement.run(
+      lineageWorkspaceId(project, root.root_asset_id),
+      project,
+      root.selected_at || null,
+      timestamp,
+      timestamp,
+      project,
+      root.root_asset_id
+    );
+  }
+}
+function activeWorkspace(database, project) {
+  const row = database.prepare(`
+    select * from lineage_workspaces
+    where project_id = ? and status != 'archived'
+    order by active_at desc nulls last, updated_at desc
+    limit 1
+  `).get(project);
+  return row ? rowToWorkspace(row) : null;
+}
+function activeLineageWorkspaceRoot(project) {
+  const database = lineageDb();
+  try {
+    seedLegacyWorkspaces(database, project);
+    return activeWorkspace(database, project)?.root_asset_id;
+  } finally {
+    database.close();
+  }
+}
+
+// src/server/assetLineage.ts
+var LineageError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function requireAsset(database, project, assetId) {
+  const row = database.prepare("select id from assets where project_id = ? and id = ?").get(project, assetId);
+  if (!row) throw new LineageError(`Unknown indexed asset: ${assetId}`, 404);
+}
+function parentOf(database, project, assetId) {
+  const row = database.prepare("select parent_asset_id from asset_edges where project_id = ? and child_asset_id = ? order by created_at limit 1").get(project, assetId);
+  return row?.parent_asset_id;
+}
+function rootFor(database, project, assetId) {
+  let root = assetId;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(root)) {
+    seen.add(root);
+    const parent = parentOf(database, project, root);
+    if (!parent) return root;
+    root = parent;
+  }
+  return assetId;
+}
+function latestSelectedRoot(database, project) {
+  const row = database.prepare("select root_asset_id from asset_selections where project_id = ? order by selected_at desc limit 1").get(project);
+  return row?.root_asset_id;
+}
+function resolveRoot(database, project, rootAssetId) {
+  if (rootAssetId) {
+    requireAsset(database, project, rootAssetId);
+    return rootAssetId;
+  }
+  const root = activeLineageWorkspaceRoot(project) || latestSelectedRoot(database, project);
+  if (!root) throw new LineageError("Lineage command requires --root unless a project selection exists");
+  requireAsset(database, project, root);
+  return root;
+}
+function edgeId(project, parent, child) {
+  return `${project}:${parent}:derived_from:${child}`;
+}
+function canPreviewLocally(mediaType, localPath) {
+  return Boolean(localPath && ["image", "video", "gif"].includes(mediaType));
+}
+function localPreviewUrl(project, localPath) {
+  if (!localPath) return void 0;
+  const params = new URLSearchParams({ project, path: localPath });
+  return `/api/assets/local-preview?${params.toString()}`;
+}
+function linkLineageAssets(project, fields) {
+  const database = lineageDb();
+  requireAsset(database, project, fields.parentAssetId);
+  requireAsset(database, project, fields.childAssetId);
+  if (fields.parentAssetId === fields.childAssetId) throw new LineageError("Lineage link cannot point to itself");
+  const edge = {
+    id: edgeId(project, fields.parentAssetId, fields.childAssetId),
+    parent_asset_id: fields.parentAssetId,
+    child_asset_id: fields.childAssetId,
+    relation_type: "derived_from",
+    created_at: nowIso()
+  };
+  if (!fields.confirmWrite) {
+    database.close();
+    return { ok: true, dryRun: true, edge };
+  }
+  database.prepare(`
+    insert into asset_edges (id, project_id, parent_asset_id, child_asset_id, relation_type, created_at)
+    values (?, ?, ?, ?, 'derived_from', ?)
+    on conflict(project_id, parent_asset_id, child_asset_id, relation_type) do nothing
+  `).run(edge.id, project, edge.parent_asset_id, edge.child_asset_id, edge.created_at);
+  database.close();
+  return { ok: true, message: `Linked ${edge.child_asset_id} from ${edge.parent_asset_id}`, edge };
+}
+function descendants(database, project, root) {
+  const edges = [];
+  const queue = [root];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const parent = queue.shift();
+    if (seen.has(parent)) continue;
+    seen.add(parent);
+    const rows = database.prepare("select id, parent_asset_id, child_asset_id, relation_type, created_at from asset_edges where project_id = ? and parent_asset_id = ? order by created_at").all(project, parent);
+    edges.push(...rows);
+    queue.push(...rows.map((row) => row.child_asset_id));
+  }
+  return edges;
+}
+function getLineageSnapshot(project, assetId) {
+  const database = lineageDb();
+  requireAsset(database, project, assetId);
+  const root = rootFor(database, project, assetId);
+  const edges = descendants(database, project, root);
+  const ids = [.../* @__PURE__ */ new Set([root, ...edges.flatMap((edge) => [edge.parent_asset_id, edge.child_asset_id])])];
+  const placeholders = ids.map(() => "?").join(",");
+  const rows = database.prepare(`
+    select a.id asset_id, a.project_id project, a.source, a.title, a.media_type, a.status, a.channel, a.campaign,
+      a.local_path, a.s3_key, a.checksum_sha256, coalesce(r.review_state, 'unreviewed') review_state,
+      r.notes review_notes, l.x layout_x, l.y layout_y
+    from assets a left join asset_reviews r on r.asset_id = a.id
+      left join asset_layouts l on l.project_id = a.project_id and l.root_asset_id = ? and l.asset_id = a.id
+    where a.project_id = ? and a.id in (${placeholders})
+  `).all(root, project, ...ids);
+  const selected = selectedRows(database, project, root);
+  const childIds = new Set(edges.map((edge) => edge.parent_asset_id));
+  const selectedIds = new Set(selected.map((row) => row.asset_id));
+  const selections = selected.map((row) => ({
+    asset_id: row.asset_id,
+    notes: row.notes || void 0,
+    position: Number(row.position || 0),
+    selected_at: row.selected_at
+  }));
+  const selection = selections[0] || null;
+  const nodes = rows.map((row) => {
+    const position = typeof row.layout_x === "number" && typeof row.layout_y === "number" ? { x: row.layout_x, y: row.layout_y } : void 0;
+    const { layout_x: _layoutX, layout_y: _layoutY, ...node } = row;
+    const nodeSelection = selections.find((item) => item.asset_id === row.asset_id);
+    return {
+      ...node,
+      is_latest: !childIds.has(row.asset_id),
+      position,
+      preview_url: canPreviewLocally(row.media_type, row.local_path) ? localPreviewUrl(project, row.local_path) : void 0,
+      selection_note: nodeSelection?.notes,
+      user_selected: selectedIds.has(row.asset_id)
+    };
+  });
+  database.close();
+  return {
+    project,
+    root_asset_id: root,
+    active_asset_id: assetId,
+    selected: selections.map((row) => row.asset_id),
+    selection,
+    selections,
+    latest: nodes.filter((node) => node.is_latest).map((node) => node.asset_id),
+    nodes,
+    edges,
+    fetchedAt: nowIso()
+  };
+}
+function getLineageNextAsset(project, rootAssetId) {
+  const database = lineageDb();
+  const root = resolveRoot(database, project, rootAssetId);
+  database.close();
+  const snapshot = getLineageSnapshot(project, root);
+  const selectedNodes = snapshot.selected.map((assetId) => snapshot.nodes.find((node) => node.asset_id === assetId)).filter((node) => Boolean(node));
+  const latestNodes = snapshot.nodes.filter((node) => snapshot.latest.includes(node.asset_id));
+  const warnings = [];
+  for (const selectedNode of selectedNodes) {
+    if (selectedNode.is_latest) continue;
+    warnings.push("Selected asset is not a latest leaf; agents should treat this as an intentional branch choice.");
+  }
+  if (selectedNodes.length > 0) {
+    return {
+      project,
+      root_asset_id: snapshot.root_asset_id,
+      strategy: "selected",
+      selection_mode: selectedNodes.length > 1 ? "multiple" : "single",
+      recommended_action: "evolve_variations",
+      reason: "user_selected",
+      next_asset: selectedNodes[0],
+      next_assets: selectedNodes,
+      latest: snapshot.latest,
+      selected: snapshot.selected,
+      selection: snapshot.selection,
+      selections: snapshot.selections,
+      candidates: latestNodes,
+      warnings,
+      fetchedAt: nowIso()
+    };
+  }
+  if (latestNodes.length === 1) {
+    return {
+      project,
+      root_asset_id: snapshot.root_asset_id,
+      strategy: "single_latest",
+      selection_mode: "fallback",
+      recommended_action: "evolve_variations",
+      reason: "single_latest_fallback",
+      next_asset: latestNodes[0],
+      next_assets: [latestNodes[0]],
+      latest: snapshot.latest,
+      selected: snapshot.selected,
+      selection: snapshot.selection,
+      selections: snapshot.selections,
+      candidates: latestNodes,
+      warnings,
+      fetchedAt: nowIso()
+    };
+  }
+  return {
+    project,
+    root_asset_id: snapshot.root_asset_id,
+    strategy: latestNodes.length > 1 ? "ambiguous_latest" : "empty",
+    selection_mode: "none",
+    recommended_action: latestNodes.length > 1 ? "choose_next_base" : "none",
+    reason: latestNodes.length > 1 ? "multiple_latest_no_selection" : "no_lineage_candidates",
+    next_asset: null,
+    next_assets: [],
+    latest: snapshot.latest,
+    selected: snapshot.selected,
+    selection: snapshot.selection,
+    selections: snapshot.selections,
+    candidates: latestNodes,
+    warnings,
+    fetchedAt: nowIso()
+  };
+}
+
+// src/server/assetLineageHandoff.ts
+var publicPackageCommand = "npx @mean-weasel/lineage";
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function lineageCommand(command, project, rootAssetId) {
+  return `${publicPackageCommand} ${command} --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --db ${shellQuote(lineageDbPath())} --json`;
+}
+function linkChildCommand(project, rootAssetId) {
+  return `${publicPackageCommand} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --confirm-write --db ${shellQuote(lineageDbPath())} --json`;
+}
+function getLineageBrief(project, rootAssetId) {
+  const next = getLineageNextAsset(project, rootAssetId);
+  const assets = next.next_assets;
+  const asset = next.next_asset;
+  const referenceAssetIds = assets.map((item) => item.asset_id);
+  const rationale = next.selections.map((selection) => selection.notes).find(Boolean) || asset?.selection_note || next.selection?.notes;
+  const channels = [...new Set(assets.map((item) => item.channel || "unknown"))];
+  const campaigns = [...new Set(assets.map((item) => item.campaign || "unknown"))];
+  const prompt = assets.length > 0 ? [
+    assets.length === 1 ? `Create 3-4 variations from asset ${assets[0].asset_id} (${assets[0].title}).` : `Create 3-4 variations using these ${assets.length} selected references: ${referenceAssetIds.join(", ")}.`,
+    rationale ? `Preserve this selection rationale: ${rationale}` : "Preserve the strongest visible ideas while exploring distinct alternatives.",
+    `Keep project=${project}, root=${next.root_asset_id}, channels=${channels.join(",")}, campaigns=${campaigns.join(",")}.`,
+    "After generation, index outputs and link chosen children with lineage link-child."
+  ].join(" ") : "Select one to three latest lineage candidates before generating variations.";
+  return {
+    project,
+    root_asset_id: next.root_asset_id,
+    strategy: next.strategy,
+    selection_mode: next.selection_mode,
+    recommended_action: next.recommended_action,
+    reason: next.reason,
+    next_asset: asset,
+    next_assets: assets,
+    selection: next.selection,
+    selections: next.selections,
+    latest: next.latest,
+    warnings: next.warnings,
+    brief: {
+      title: asset ? `Evolve ${assets.length > 1 ? `${assets.length} selected bases` : asset.title}` : "Choose next lineage base",
+      objective: asset ? "Generate the next branch of visual variations from the selected lineage base or bases." : "Resolve the next base before generation.",
+      prompt,
+      reference_asset_id: asset?.asset_id,
+      reference_asset_ids: referenceAssetIds,
+      rationale
+    },
+    handoff: {
+      next_command: lineageCommand("next", project, next.root_asset_id),
+      inspect_command: asset ? `${publicPackageCommand} inspect --project ${shellQuote(project)} --asset-id ${shellQuote(asset.asset_id)} --db ${shellQuote(lineageDbPath())} --json` : void 0,
+      link_child_command: asset ? linkChildCommand(project, next.root_asset_id) : void 0
+    },
+    fetchedAt: nowIso()
+  };
+}
+function linkSelectedLineageChild(project, fields) {
+  const next = getLineageNextAsset(project, fields.rootAssetId);
+  if (!next.next_asset) throw new LineageError("Cannot link child until a next base is selected or unambiguous");
+  const result = linkLineageAssets(project, {
+    childAssetId: fields.childAssetId,
+    confirmWrite: fields.confirmWrite,
+    parentAssetId: next.next_asset.asset_id
+  });
+  return {
+    ...result,
+    root_asset_id: next.root_asset_id,
+    parent_asset_id: next.next_asset.asset_id,
+    child_asset_id: fields.childAssetId,
+    reference_asset_ids: next.next_assets.map((asset) => asset.asset_id),
+    warning: next.next_assets.length > 1 ? "Linked child to the primary selected base; add explicit edges to other selected references if the child derives from them too." : void 0
+  };
+}
+
+// src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
   SIGTERM: 143
 };
 function packageRoot() {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+  return resolve3(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
-    const packageInfo = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8"));
+    const packageInfo = JSON.parse(readFileSync3(join5(packageRoot(), "package.json"), "utf8"));
     return packageInfo.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -23,9 +1201,9 @@ function packageVersion() {
 }
 function dataRoot(displayName) {
   if (process.env.LINEAGE_HOME) return process.env.LINEAGE_HOME;
-  if (platform() === "darwin") return join(homedir(), "Library", "Application Support", displayName);
-  if (platform() === "win32") return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), displayName);
-  return join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
+  if (platform() === "darwin") return join5(homedir(), "Library", "Application Support", displayName);
+  if (platform() === "win32") return join5(process.env.APPDATA || join5(homedir(), "AppData", "Roaming"), displayName);
+  return join5(process.env.XDG_DATA_HOME || join5(homedir(), ".local", "share"), displayName.toLowerCase().replace(/\s+/g, "-"));
 }
 function readOption(args, name) {
   const prefix = `${name}=`;
@@ -43,7 +1221,7 @@ function resolveStartOptions(config, args) {
     throw new Error(`Invalid port: ${rawPort}`);
   }
   return {
-    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join(runtimeDir, `${config.binName}.sqlite`),
+    dbPath: readOption(args, "--db") || process.env.LINEAGE_DB || join5(runtimeDir, `${config.binName}.sqlite`),
     host: readOption(args, "--host") || process.env.HOST || "127.0.0.1",
     json: args.includes("--json"),
     open: args.includes("--open"),
@@ -55,6 +1233,10 @@ function printHelp(config) {
 
 Usage:
   ${config.binName} start [--port <port>] [--host <host>] [--db <path>] [--open] [--json]
+  ${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} link-child --root <asset-id> --child <asset-id> [--project <project>] [--confirm-write] [--db <path>] [--json]
   ${config.binName} --help
   ${config.binName} --version
 
@@ -66,6 +1248,80 @@ function openBrowser(url) {
   const opener = spawn(command, args, { detached: true, stdio: "ignore" });
   opener.unref();
 }
+function positionalArgs(args) {
+  const values = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith("--")) {
+      if (!arg.includes("=") && args[index + 1] && !args[index + 1].startsWith("--")) index += 1;
+      continue;
+    }
+    values.push(arg);
+  }
+  return values;
+}
+function resolveDataCommandOptions(args) {
+  const positions = positionalArgs(args);
+  const options = {
+    assetId: readOption(args, "--asset-id") || positions[0],
+    childAssetId: readOption(args, "--child"),
+    confirmWrite: args.includes("--confirm-write"),
+    dbPath: readOption(args, "--db"),
+    json: args.includes("--json"),
+    project: readOption(args, "--project") || process.env.LINEAGE_DEFAULT_PRODUCT || defaultProduct,
+    rootAssetId: readOption(args, "--root")
+  };
+  if (options.dbPath) process.env.LINEAGE_DB = options.dbPath;
+  return options;
+}
+function runLineageDataCommand(command, args) {
+  const options = resolveDataCommandOptions(args);
+  if (command === "next") return getLineageNextAsset(options.project, options.rootAssetId || options.assetId);
+  if (command === "brief") return getLineageBrief(options.project, options.rootAssetId || options.assetId);
+  if (command === "inspect") {
+    if (!options.assetId) throw new Error("lineage inspect requires --asset-id");
+    return getLineageSnapshot(options.project, options.assetId);
+  }
+  if (command === "link-child") {
+    if (!options.childAssetId) throw new Error("lineage link-child requires --child");
+    return linkSelectedLineageChild(options.project, {
+      childAssetId: options.childAssetId,
+      confirmWrite: options.confirmWrite,
+      rootAssetId: options.rootAssetId || options.assetId
+    });
+  }
+  throw new Error(`Unknown command: ${command}`);
+}
+function printDataResult(command, result, json) {
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (command === "next" && result && typeof result === "object" && "reason" in result) {
+    const next = result;
+    console.log(next.next_asset ? `${next.next_asset.asset_id}: ${next.next_asset.title}` : `No next asset: ${next.reason}`);
+    console.log(`Root: ${next.root_asset_id}`);
+    return;
+  }
+  if (command === "brief" && result && typeof result === "object" && "brief" in result) {
+    const brief = result;
+    console.log(brief.brief.title);
+    console.log(brief.brief.prompt);
+    return;
+  }
+  if (command === "inspect" && result && typeof result === "object" && "nodes" in result) {
+    const snapshot = result;
+    console.log(`${snapshot.root_asset_id}: ${snapshot.nodes.length} node(s), ${snapshot.edges.length} edge(s)`);
+    console.log(`Active: ${snapshot.active_asset_id}`);
+    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"}`);
+    return;
+  }
+  console.log(String(result));
+}
 function start(config, args) {
   let options;
   const json = args.includes("--json");
@@ -77,14 +1333,14 @@ function start(config, args) {
     else console.error(`${config.binName}: ${message}`);
     process.exit(1);
   }
-  const serverPath = join(packageRoot(), "dist", "server.js");
-  if (!existsSync(serverPath)) {
+  const serverPath = join5(packageRoot(), "dist", "server.js");
+  if (!existsSync4(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}`);
     process.exit(1);
   }
-  mkdirSync(dirname(options.dbPath), { recursive: true });
+  mkdirSync4(dirname3(options.dbPath), { recursive: true });
   const url = `http://${options.host}:${options.port}`;
   if (options.json) {
     console.log(JSON.stringify({ channel: config.channel, dbPath: options.dbPath, host: options.host, port: options.port, status: "starting", url }, null, 2));
@@ -126,11 +1382,25 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     console.log(packageVersion());
     process.exit(0);
   }
-  const [command] = args;
+  const normalizedArgs = args[0] === "lineage" ? args.slice(1) : args;
+  const [command] = normalizedArgs;
   if (command === "start") {
-    start(config, args.slice(1));
+    start(config, normalizedArgs.slice(1));
     return;
   }
+  if (command === "next" || command === "brief" || command === "inspect" || command === "link-child") {
+    const commandArgs = normalizedArgs.slice(1);
+    const json2 = commandArgs.includes("--json");
+    try {
+      printDataResult(command, runLineageDataCommand(command, commandArgs), json2);
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      if (json2) console.error(JSON.stringify({ ok: false, command, error: message2 }, null, 2));
+      else console.error(`${config.binName}: ${message2}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
   const json = args.includes("--json");
   const message = `Unknown command: ${command}`;
   if (json) console.error(JSON.stringify({ ok: false, command, error: message }, null, 2));