@mean-weasel/lineage 0.1.23 → 0.1.25

package/dist/server.js

@@ -1,7 +1,7 @@
 // src/server.ts
 import express2 from "express";
 import multer from "multer";
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { join as join14 } from "node:path";
 
 // src/server/assetCore.ts
@@ -980,6 +980,21 @@ function lineageDb() {
       where status = 'pending';
     create index if not exists asset_reroll_requests_root_status
       on asset_reroll_requests(project_id, root_asset_id, status, created_at);
+    create table if not exists asset_social_marks (
+      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,
+      marked_by text not null,
+      marked_at text not null,
+      unmarked_by text,
+      unmarked_at text,
+      updated_at text not null,
+      unique(project_id, root_asset_id, asset_id)
+    );
+    create index if not exists asset_social_marks_root_active
+      on asset_social_marks(project_id, root_asset_id, unmarked_at, marked_at);
     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')),
@@ -3977,6 +3992,19 @@ function getLineageSnapshot(project, assetId) {
     const request = rerollRequestFrom(row);
     return [request.node_asset_id, withRerollTask(request, lineageTasksByNode.get(request.node_asset_id)?.reroll)];
   }));
+  const hasSocialMarks = database.prepare("select 1 from sqlite_master where type = 'table' and name = 'asset_social_marks'").get() !== void 0;
+  const socialMarkRows = ids.length > 0 && hasSocialMarks ? database.prepare(`select * from asset_social_marks where project_id = ? and root_asset_id = ? and unmarked_at is null and asset_id in (${placeholders2})`).all(project, root, ...ids) : [];
+  const socialMarksByNode = new Map(socialMarkRows.map((row) => [String(row.asset_id), {
+    active: true,
+    asset_id: String(row.asset_id),
+    id: String(row.id),
+    marked_at: String(row.marked_at),
+    marked_by: String(row.marked_by),
+    notes: rowString(row.notes),
+    project_id: String(row.project_id),
+    root_asset_id: String(row.root_asset_id),
+    updated_at: String(row.updated_at)
+  }]));
   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) => ({
@@ -4005,6 +4033,7 @@ function getLineageSnapshot(project, assetId) {
       preview_url: canPreviewLocally(row.media_type, previewPath) ? localPreviewUrl(project, previewPath) : void 0,
       reroll_request: rerollsByNode.get(row.asset_id),
       selection_note: nodeSelection?.notes,
+      social_mark: socialMarksByNode.get(row.asset_id),
       user_selected: selectedIds.has(row.asset_id)
     };
   });
@@ -4769,6 +4798,11 @@ function removeLineageNode(project, fields) {
     `);
     for (const edge of reparentedEdges) insertEdge.run(edge.id, project, edge.parent_asset_id, edge.child_asset_id, edge.created_at);
     database.prepare("delete from asset_layouts where project_id = ? and root_asset_id = ? and asset_id = ?").run(project, root, fields.assetId);
+    database.prepare(`
+      update asset_social_marks
+      set unmarked_by = 'lineage:remove-node', unmarked_at = ?, updated_at = ?
+      where project_id = ? and root_asset_id = ? and asset_id = ? and unmarked_at is null
+    `).run(timestamp, timestamp, project, root, fields.assetId);
     compactSelectionsAfterRemove(database, project, root, fields.assetId, timestamp);
     database.exec("commit");
   } catch (error) {
@@ -4789,6 +4823,277 @@ function removeLineageNode(project, fields) {
   };
 }
 
+// src/server/assetSocialMarks.ts
+import { accessSync, constants, existsSync as existsSync8 } from "node:fs";
+import { isAbsolute as isAbsolute3, resolve as resolve6 } from "node:path";
+function markFromRow(row) {
+  return {
+    active: row.unmarked_at === null,
+    asset_id: row.asset_id,
+    id: row.id,
+    marked_at: row.marked_at,
+    marked_by: row.marked_by,
+    notes: row.notes || void 0,
+    project_id: row.project_id,
+    root_asset_id: row.root_asset_id,
+    unmarked_at: row.unmarked_at || void 0,
+    unmarked_by: row.unmarked_by || void 0,
+    updated_at: row.updated_at
+  };
+}
+function requireCanonicalSnapshot(project, rootAssetId) {
+  const snapshot = getLineageSnapshot(project, rootAssetId);
+  if (snapshot.root_asset_id !== rootAssetId) {
+    throw new LineageError(`Asset ${rootAssetId} is not a canonical lineage canvas root`, 400);
+  }
+  return snapshot;
+}
+function resolveVisibleNode(snapshot, asset) {
+  const exactId = snapshot.nodes.find((node) => node.asset_id === asset);
+  if (exactId) return exactId;
+  const title = asset.trim().toLocaleLowerCase();
+  const matches = snapshot.nodes.filter((node) => node.title.trim().toLocaleLowerCase() === title);
+  if (matches.length > 1) throw new LineageError(`Asset title "${asset}" matches multiple visible nodes; use an exact asset ID.`, 409);
+  if (matches.length === 1) return matches[0];
+  throw new LineageError(`Asset ${asset} is not visible in lineage canvas ${snapshot.root_asset_id}`, 404);
+}
+function rootChannel(snapshot) {
+  return snapshot.nodes.find((node) => node.asset_id === snapshot.root_asset_id)?.channel;
+}
+function requireActor(actor, field) {
+  const normalized = actor.trim();
+  if (!normalized) throw new LineageError(`Social mark ${field} is required`);
+  return normalized;
+}
+function socialMarkId(project, rootAssetId, assetId) {
+  return `${project}:${rootAssetId}:social:${assetId}`;
+}
+function activeRow(project, rootAssetId, assetId) {
+  const database = lineageDb();
+  try {
+    return database.prepare(`
+      select * from asset_social_marks
+      where project_id = ? and root_asset_id = ? and asset_id = ? and unmarked_at is null
+    `).get(project, rootAssetId, assetId);
+  } finally {
+    database.close();
+  }
+}
+function mutationResponse(project, rootAssetId, active, mark, dryRun) {
+  return {
+    active,
+    ...dryRun ? { dryRun } : {},
+    ...mark ? { mark } : {},
+    ok: true,
+    snapshot: getLineageSnapshot(project, rootAssetId)
+  };
+}
+function markAssetSocial(project, fields) {
+  const snapshot = requireCanonicalSnapshot(project, fields.rootAssetId);
+  const node = resolveVisibleNode(snapshot, fields.asset);
+  const markedBy = requireActor(fields.markedBy, "markedBy");
+  requireLineageWorkspaceClaimForWrite({
+    channel: rootChannel(snapshot),
+    claimToken: fields.claimToken,
+    confirmWrite: fields.confirmWrite,
+    project,
+    rootAssetId: fields.rootAssetId,
+    writeKind: "social_mark"
+  });
+  const existing = activeRow(project, fields.rootAssetId, node.asset_id);
+  if (existing) return mutationResponse(project, fields.rootAssetId, true, markFromRow(existing), fields.confirmWrite ? void 0 : true);
+  const timestamp = nowIso();
+  const preview = {
+    active: true,
+    asset_id: node.asset_id,
+    id: socialMarkId(project, fields.rootAssetId, node.asset_id),
+    marked_at: timestamp,
+    marked_by: markedBy,
+    notes: fields.notes?.trim() || void 0,
+    project_id: project,
+    root_asset_id: fields.rootAssetId,
+    updated_at: timestamp
+  };
+  if (!fields.confirmWrite) return mutationResponse(project, fields.rootAssetId, true, preview, true);
+  const database = lineageDb();
+  try {
+    database.prepare(`
+      insert into asset_social_marks (
+        id, project_id, root_asset_id, asset_id, notes, marked_by, marked_at,
+        unmarked_by, unmarked_at, updated_at
+      ) values (?, ?, ?, ?, ?, ?, ?, null, null, ?)
+      on conflict(project_id, root_asset_id, asset_id) do update set
+        notes = excluded.notes,
+        marked_by = excluded.marked_by,
+        marked_at = excluded.marked_at,
+        unmarked_by = null,
+        unmarked_at = null,
+        updated_at = excluded.updated_at
+    `).run(
+      preview.id,
+      project,
+      fields.rootAssetId,
+      node.asset_id,
+      preview.notes || null,
+      markedBy,
+      timestamp,
+      timestamp
+    );
+  } finally {
+    database.close();
+  }
+  return mutationResponse(project, fields.rootAssetId, true, markFromRow(activeRow(project, fields.rootAssetId, node.asset_id)));
+}
+function unmarkAssetSocial(project, fields) {
+  const snapshot = requireCanonicalSnapshot(project, fields.rootAssetId);
+  const node = resolveVisibleNode(snapshot, fields.asset);
+  const unmarkedBy = requireActor(fields.unmarkedBy, "unmarkedBy");
+  requireLineageWorkspaceClaimForWrite({
+    channel: rootChannel(snapshot),
+    claimToken: fields.claimToken,
+    confirmWrite: fields.confirmWrite,
+    project,
+    rootAssetId: fields.rootAssetId,
+    writeKind: "social_unmark"
+  });
+  const existing = activeRow(project, fields.rootAssetId, node.asset_id);
+  if (!existing) return mutationResponse(project, fields.rootAssetId, false, void 0, fields.confirmWrite ? void 0 : true);
+  const timestamp = nowIso();
+  const preview = markFromRow({
+    ...existing,
+    unmarked_at: timestamp,
+    unmarked_by: unmarkedBy,
+    updated_at: timestamp
+  });
+  if (!fields.confirmWrite) return mutationResponse(project, fields.rootAssetId, false, preview, true);
+  const database = lineageDb();
+  try {
+    database.prepare(`
+      update asset_social_marks
+      set unmarked_by = ?, unmarked_at = ?, updated_at = ?
+      where project_id = ? and root_asset_id = ? and asset_id = ? and unmarked_at is null
+    `).run(unmarkedBy, timestamp, timestamp, project, fields.rootAssetId, node.asset_id);
+  } finally {
+    database.close();
+  }
+  return mutationResponse(project, fields.rootAssetId, false, preview);
+}
+function absoluteLocalPath2(reference) {
+  if (!reference) return void 0;
+  if (isAbsolute3(reference)) return reference;
+  const repoRelative = resolve6(repoRoot, reference);
+  return existsSync8(repoRelative) || reference === ".asset-scratch" || reference.startsWith(".asset-scratch/") ? repoRelative : resolve6(repoRoot, ".asset-scratch", reference);
+}
+function isReadable(path) {
+  try {
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listItem(project, rootAssetId, node, row) {
+  const relativePath = node.current_attempt?.file_path || node.local_path;
+  const absolutePath = absoluteLocalPath2(relativePath);
+  const exists = absolutePath ? existsSync8(absolutePath) : false;
+  const warnings = [];
+  if (absolutePath && !exists) warnings.push(`Asset ${node.asset_id} local file is missing: ${absolutePath}`);
+  if (absolutePath && exists && !isReadable(absolutePath)) {
+    warnings.push(`Asset ${node.asset_id} local file is unreadable: ${absolutePath}. Check file permissions before handoff.`);
+  }
+  if (!absolutePath && node.s3_key) {
+    warnings.push(`Asset ${node.asset_id} is only available in non-local storage; create a readable local copy before handoff.`);
+  }
+  if (!absolutePath && !node.s3_key) warnings.push(`Asset ${node.asset_id} has no local file or storage key.`);
+  const base = `--project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --asset ${shellQuote(node.asset_id)}`;
+  return {
+    ...markFromRow(row),
+    checksum_sha256: node.current_attempt?.checksum_sha256 || node.checksum_sha256,
+    commands: {
+      mark: lineageCliCommand(`social mark ${base} --confirm-write`),
+      unmark: lineageCliCommand(`social unmark ${base} --confirm-write`)
+    },
+    current_attempt: node.current_attempt,
+    local: {
+      absolute_path: absolutePath,
+      exists,
+      relative_path: relativePath
+    },
+    media_type: node.media_type,
+    s3: node.s3_key ? { key: node.s3_key } : void 0,
+    source: node.source,
+    title: node.title,
+    warnings
+  };
+}
+function listAssetSocialMarks(project, rootAssetId) {
+  const snapshot = requireCanonicalSnapshot(project, rootAssetId);
+  const database = lineageDb();
+  let rows;
+  try {
+    const hasSocialMarks = database.prepare("select 1 from sqlite_master where type = 'table' and name = 'asset_social_marks'").get() !== void 0;
+    rows = hasSocialMarks ? database.prepare(`
+        select * from asset_social_marks
+        where project_id = ? and root_asset_id = ? and unmarked_at is null
+        order by marked_at, asset_id
+      `).all(project, rootAssetId) : [];
+  } finally {
+    database.close();
+  }
+  const nodesById = new Map(snapshot.nodes.map((node) => [node.asset_id, node]));
+  return {
+    commands: {
+      mark: lineageCliCommand(`social mark --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --asset <asset-id> --confirm-write`)
+    },
+    fetchedAt: nowIso(),
+    marks: rows.flatMap((row) => {
+      const node = nodesById.get(row.asset_id);
+      return node ? [listItem(project, rootAssetId, node, row)] : [];
+    }),
+    project,
+    root_asset_id: rootAssetId,
+    schema_version: "lineage.social_marks.v1",
+    workspace: {
+      id: lineageWorkspaceId(project, rootAssetId),
+      root_asset_id: rootAssetId
+    }
+  };
+}
+function bodyString(req, key) {
+  const value = req.body?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function requestClaimToken(req) {
+  return req.header("X-Lineage-Claim-Token") || bodyString(req, "claimToken");
+}
+function registerAssetSocialMarkRoutes(app2, projectFrom2, asyncRoute2) {
+  app2.get("/api/lineage/:rootAssetId/social-marks", asyncRoute2((req, res) => {
+    res.json(listAssetSocialMarks(
+      projectFrom2({ query: req.query }),
+      req.params.rootAssetId
+    ));
+  }));
+  app2.post("/api/lineage/:rootAssetId/social-marks/:assetId", asyncRoute2((req, res) => {
+    res.json(markAssetSocial(projectFrom2({ body: req.body, query: req.query }), {
+      asset: req.params.assetId,
+      claimToken: requestClaimToken(req),
+      confirmWrite: req.body?.confirmWrite === true,
+      markedBy: bodyString(req, "markedBy") || bodyString(req, "actor") || "human",
+      notes: bodyString(req, "notes"),
+      rootAssetId: req.params.rootAssetId
+    }));
+  }));
+  app2.post("/api/lineage/:rootAssetId/social-marks/:assetId/unmark", asyncRoute2((req, res) => {
+    res.json(unmarkAssetSocial(projectFrom2({ body: req.body, query: req.query }), {
+      asset: req.params.assetId,
+      claimToken: requestClaimToken(req),
+      confirmWrite: req.body?.confirmWrite === true,
+      rootAssetId: req.params.rootAssetId,
+      unmarkedBy: bodyString(req, "unmarkedBy") || bodyString(req, "actor") || "human"
+    }));
+  }));
+}
+
 // src/server/assetLedger.ts
 function allAssets(project, source) {
   const first = listAssets(project, { page: 1, pageSize: 100, source });
@@ -6867,7 +7172,7 @@ function registerAdapterRoutes(app2, projectFrom2, asyncRoute2) {
 import { Router } from "express";
 
 // src/server/contentBatchImport.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { basename as basename3, join as join10, relative as relative3 } from "node:path";
 function walk(dir) {
   return readdirSync3(dir, { withFileTypes: true }).flatMap((entry) => {
@@ -6922,7 +7227,7 @@ function itemFromFile(file) {
 }
 function demoMarkdownItems(kind) {
   const root = process.env.LINEAGE_CONTENT_SOURCE_ROOT || join10(repoRoot, "demo-project", "channels");
-  if (!existsSync8(root)) return [];
+  if (!existsSync9(root)) return [];
   return walk(root).map(itemFromFile).filter((item) => Boolean(item)).filter((item) => kind === "all" || `${item.kind}s` === kind).sort((a, b) => a.sourcePath.localeCompare(b.sourcePath));
 }
 function importDemoContentBatch(project, options) {
@@ -7261,8 +7566,8 @@ function contentBatchRouter(projectFrom2) {
 }
 
 // src/server/generationReceipts.ts
-import { existsSync as existsSync9, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
-import { relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync10, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
+import { relative as relative4, resolve as resolve7 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/shared/generationOutputManifest.ts
@@ -7800,8 +8105,8 @@ function isPathInside2(child, parent) {
   return Boolean(rel) && !rel.startsWith("..") && !rel.startsWith("/");
 }
 function scratchCandidate(file) {
-  const scratchRoot = resolve6(repoRoot, ".asset-scratch");
-  const candidate = file.startsWith(".asset-scratch/") || resolve6(file).startsWith(scratchRoot) ? resolve6(repoRoot, file) : resolve6(scratchRoot, file);
+  const scratchRoot = resolve7(repoRoot, ".asset-scratch");
+  const candidate = file.startsWith(".asset-scratch/") || resolve7(file).startsWith(scratchRoot) ? resolve7(repoRoot, file) : resolve7(scratchRoot, file);
   if (!isPathInside2(candidate, scratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
   return { candidate, scratchRoot };
 }
@@ -7811,7 +8116,7 @@ function resolveScratchManifestPath(file) {
 }
 function resolveScratchFile(file) {
   const { candidate, scratchRoot } = scratchCandidate(file);
-  if (!existsSync9(candidate)) throw new GenerationReceiptError(`Missing import file: ${file}`, 404);
+  if (!existsSync10(candidate)) throw new GenerationReceiptError(`Missing import file: ${file}`, 404);
   const realScratchRoot = realpathSync2(scratchRoot);
   const realCandidate = realpathSync2(candidate);
   if (!isPathInside2(realCandidate, realScratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
@@ -8143,7 +8448,7 @@ function registerLineageTaskRoutes(app2, projectFrom2, asyncRoute2) {
 
 // src/server/assetLineageDemo.ts
 import { createHash as createHash5 } from "node:crypto";
-import { copyFileSync as copyFileSync3, existsSync as existsSync10, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync7, mkdtempSync, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname as dirname5, join as join11, posix } from "node:path";
 import { gunzipSync } from "node:zlib";
@@ -8215,9 +8520,9 @@ function swissifierRerollFixturePath(attempt) {
 }
 function swissifierSourcePath(manifest, asset, sourceDir) {
   const direct = join11(sourceDir, asset.file);
-  if (existsSync10(direct)) return direct;
+  if (existsSync11(direct)) return direct;
   const nested = join11(sourceDir, manifest.media.target_dir, asset.file);
-  return existsSync10(nested) ? nested : null;
+  return existsSync11(nested) ? nested : null;
 }
 function swissifierMediaState(manifest) {
   const missing = [];
@@ -8225,7 +8530,7 @@ function swissifierMediaState(manifest) {
   for (const asset of manifest.assets) {
     const relativePath = swissifierRelativePath(manifest, asset);
     const path = swissifierFilePath(manifest, asset);
-    if (!existsSync10(path)) {
+    if (!existsSync11(path)) {
       missing.push(relativePath);
       continue;
     }
@@ -8317,7 +8622,7 @@ async function downloadBuffer(url, maxBytes) {
   return buffer;
 }
 function missingDemoMedia(project) {
-  return demoAssets.filter((asset) => !existsSync10(demoFilePath(project, asset))).map((asset) => demoRelativePath(project, asset));
+  return demoAssets.filter((asset) => !existsSync11(demoFilePath(project, asset))).map((asset) => demoRelativePath(project, asset));
 }
 function demoSeedMediaStatus(project = defaultProject) {
   const missing = missingDemoMedia(project);
@@ -8512,7 +8817,7 @@ function writeDemoFiles(project) {
 }
 function swissifierRerollAsset(attempt) {
   const source = swissifierRerollFixturePath(attempt);
-  if (!existsSync10(source)) throw new Error(`Missing Swissifier re-roll fixture media: ${attempt.file}`);
+  if (!existsSync11(source)) throw new Error(`Missing Swissifier re-roll fixture media: ${attempt.file}`);
   const body = readFileSync6(source);
   if (body.length !== attempt.size_bytes) throw new Error(`Unexpected Swissifier re-roll fixture size for ${attempt.file}`);
   const checksumSha256 = sha256Hex(body);
@@ -8935,8 +9240,8 @@ function registerLineageWorkspaceRoutes(app2, projectFrom2, asyncRoute2) {
 // src/server/runtimeInfo.ts
 import { createHash as createHash6 } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync11, lstatSync as lstatSync3, readFileSync as readFileSync7, readdirSync as readdirSync4, readlinkSync, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute3, join as join12, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync12, lstatSync as lstatSync3, readFileSync as readFileSync7, readdirSync as readdirSync4, readlinkSync, realpathSync as realpathSync3, statSync as statSync5 } from "node:fs";
+import { dirname as dirname6, isAbsolute as isAbsolute4, join as join12, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/shared/runtimeInfoTypes.ts
@@ -8955,7 +9260,7 @@ function isLineagePackageRoot(root) {
 }
 function executingCodeRoot() {
   const moduleDirectory = dirname6(fileURLToPath2(import.meta.url));
-  const candidates = [resolve7(moduleDirectory, "../.."), resolve7(moduleDirectory, "..")];
+  const candidates = [resolve8(moduleDirectory, "../.."), resolve8(moduleDirectory, "..")];
   const root = candidates.find(isLineagePackageRoot);
   if (!root) throw new Error(`Unable to derive Lineage code root from executing module ${fileURLToPath2(import.meta.url)}`);
   return canonicalRoot(root);
@@ -8968,7 +9273,7 @@ function canonicalRoot(root) {
   try {
     return realpathSync3(root);
   } catch {
-    return resolve7(root);
+    return resolve8(root);
   }
 }
 function packageInfo(root = codeRoot) {
@@ -9068,7 +9373,7 @@ function readInstallReceipt(path, errors) {
     return void 0;
   }
   let receipt;
-  const receiptPath = resolve7(path);
+  const receiptPath = resolve8(path);
   try {
     receipt = JSON.parse(readFileSync7(receiptPath, "utf8"));
   } catch (error) {
@@ -9076,7 +9381,7 @@ function readInstallReceipt(path, errors) {
     return void 0;
   }
   if (receipt.schema_version !== lineageRuntimeInstallSchemaVersion) errors.push(`Unsupported runtime install receipt schema: ${String(receipt.schema_version)}`);
-  if (!isAbsolute3(receipt.package_root || "")) errors.push("Runtime install receipt package_root must be absolute");
+  if (!isAbsolute4(receipt.package_root || "")) errors.push("Runtime install receipt package_root must be absolute");
   if (!receipt.package_integrity?.startsWith("sha512-")) errors.push("Runtime install receipt package integrity is invalid");
   if (receipt.package_source !== "registry" && receipt.package_source !== "local") errors.push("Runtime install receipt package source is invalid");
   if (typeof receipt.package_spec !== "string" || !receipt.package_spec) errors.push("Runtime install receipt package spec is invalid");
@@ -9157,8 +9462,8 @@ function packageCodeIdentity(root, channel, info, receiptPath) {
 function getLineageCodeIdentity(channel, options = {}) {
   const root = canonicalRoot(options.root || codeRoot);
   const info = packageInfo(root);
-  if (existsSync11(join12(root, ".git"))) return checkoutCodeIdentity(root, channel, info.version);
-  if (existsSync11(join12(root, "package.json"))) {
+  if (existsSync12(join12(root, ".git"))) return checkoutCodeIdentity(root, channel, info.version);
+  if (existsSync12(join12(root, "package.json"))) {
     return packageCodeIdentity(root, channel, info, options.receiptPath ?? process.env.LINEAGE_RUNTIME_RECEIPT);
   }
   const errors = [`Code root has neither checkout metadata nor package.json: ${root}`];
@@ -9197,7 +9502,7 @@ function getLineageRuntimeInfo(options = {}) {
   const dbPath = options.dbPath || lineageDbPath();
   const channel = normalizeRuntimeChannel(options.channel || process.env.LINEAGE_CHANNEL || process.env.LINEAGE_RELEASE_CHANNEL);
   const code = options.code || getLineageCodeIdentity(channel);
-  const databaseInfo = { exists: existsSync11(dbPath), path: dbPath };
+  const databaseInfo = { exists: existsSync12(dbPath), path: dbPath };
   const schema = { migration_keys: [] };
   const serviceInstanceId = process.env.LINEAGE_SERVICE_INSTANCE_ID;
   const launcherPid = process.env.LINEAGE_LAUNCHER_PID ? Number(process.env.LINEAGE_LAUNCHER_PID) : void 0;
@@ -9337,14 +9642,14 @@ function registerManagedWriterRoute(app2, fields) {
 }
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname7, join as join13, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname7, join as join13, resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/server/lineageSelectionPacket.ts
 import { createHash as createHash7 } from "node:crypto";
-import { existsSync as existsSync12, statSync as statSync6 } from "node:fs";
-import { isAbsolute as isAbsolute4, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync13, statSync as statSync6 } from "node:fs";
+import { isAbsolute as isAbsolute5, resolve as resolve9 } from "node:path";
 var LineageSelectionPacketError = class extends Error {
   constructor(message, warnings = [], errors = [], diagnostics = []) {
     super(message);
@@ -9390,13 +9695,13 @@ function resolveWorkspace(project, options) {
 }
 function resolveLocalReference(reference) {
   if (!reference) return void 0;
-  if (isAbsolute4(reference)) return reference;
-  const repoRelative = resolve8(repoRoot, reference);
-  if (existsSync12(repoRelative)) return repoRelative;
-  return resolve8(repoRoot, ".asset-scratch", reference);
+  if (isAbsolute5(reference)) return reference;
+  const repoRelative = resolve9(repoRoot, reference);
+  if (existsSync13(repoRelative)) return repoRelative;
+  return resolve9(repoRoot, ".asset-scratch", reference);
 }
 function fileSize(path) {
-  if (!path || !existsSync12(path)) return void 0;
+  if (!path || !existsSync13(path)) return void 0;
   try {
     return statSync6(path).size;
   } catch {
@@ -9424,7 +9729,7 @@ function currentAttemptFor(node) {
 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 ? existsSync12(absolutePath) : false;
+  const localExists = absolutePath ? existsSync13(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);
@@ -9581,7 +9886,7 @@ function assetForNodeV2(node, visibleCatalogAsset, catalogById, warnings, errors
   const mediaCatalogAsset = currentAttemptCatalogAsset || (isVisibleNodeAttempt ? visibleCatalogAsset : void 0);
   const localReference = currentAttempt.file_path || mediaCatalogAsset?.local?.absolute_path || mediaCatalogAsset?.local?.relative_path || (isVisibleNodeAttempt ? node.local_path : void 0);
   const absolutePath = resolveLocalReference(localReference);
-  const localExists = absolutePath ? existsSync12(absolutePath) : false;
+  const localExists = absolutePath ? existsSync13(absolutePath) : false;
   const hasLocalClaim = Boolean(localReference);
   const s3Key = mediaCatalogAsset?.s3?.key || (isVisibleNodeAttempt ? node.s3_key : void 0);
   const hasS3 = Boolean(s3Key);
@@ -9846,7 +10151,7 @@ function getLineageSelectionPacket(project, options = {}) {
 
 // src/cli/lineageCli.ts
 function packageRoot2() {
-  return resolve9(dirname7(fileURLToPath3(import.meta.url)), "..", "..");
+  return resolve10(dirname7(fileURLToPath3(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
@@ -9879,7 +10184,7 @@ function readOptions(args, name) {
 }
 function readJsonFile(path, label) {
   try {
-    return JSON.parse(readFileSync8(resolve9(path), "utf8"));
+    return JSON.parse(readFileSync8(resolve10(path), "utf8"));
   } catch (error) {
     throw new Error(`${label} must be a readable JSON file: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
@@ -9898,7 +10203,7 @@ function parentFilesOption(value) {
   return mappings;
 }
 function resolveCliAssetRoot(args) {
-  return resolve9(readOption(args, "--asset-root") || process.env.LINEAGE_ASSET_ROOT || packageRoot);
+  return resolve10(readOption(args, "--asset-root") || process.env.LINEAGE_ASSET_ROOT || packageRoot);
 }
 function configureCliAssetRoot(args) {
   const assetRoot = resolveCliAssetRoot(args);
@@ -9963,7 +10268,7 @@ function runLineageDataCommand(command, args) {
     });
     const out = readOption(args, "--out");
     if (out) {
-      const outPath = resolve9(out);
+      const outPath = resolve10(out);
       mkdirSync8(dirname7(outPath), { recursive: true });
       writeFileSync6(outPath, `${JSON.stringify(packet, null, 2)}
 `);
@@ -10074,6 +10379,35 @@ function runLineageDataCommand(command, args) {
     }
     throw new Error(`Unknown reroll command: ${subcommand}`);
   }
+  if (command === "social") {
+    const subcommand = positionalArgs(args)[0] || "";
+    const explicitProject = readOption(args, "--project");
+    const asset = readOption(args, "--asset");
+    if (!explicitProject) throw new Error(`lineage social ${subcommand || "command"} requires --project`);
+    if (!options.rootAssetId) throw new Error(`lineage social ${subcommand || "command"} requires --root`);
+    if (subcommand === "list") return listAssetSocialMarks(explicitProject, options.rootAssetId);
+    if (!asset) throw new Error(`lineage social ${subcommand || "command"} requires --asset`);
+    if (subcommand === "mark") {
+      return markAssetSocial(explicitProject, {
+        asset,
+        claimToken: options.claimToken,
+        confirmWrite: options.confirmWrite,
+        markedBy: readOption(args, "--actor") || "agent",
+        notes: readOption(args, "--notes"),
+        rootAssetId: options.rootAssetId
+      });
+    }
+    if (subcommand === "unmark") {
+      return unmarkAssetSocial(explicitProject, {
+        asset,
+        claimToken: options.claimToken,
+        confirmWrite: options.confirmWrite,
+        rootAssetId: options.rootAssetId,
+        unmarkedBy: readOption(args, "--actor") || "agent"
+      });
+    }
+    throw new Error(`Unknown social command: ${subcommand}`);
+  }
   if (command === "tasks") {
     const subcommand = positionalArgs(args)[0] || "";
     const taskId = readOption(args, "--task");
@@ -10146,6 +10480,7 @@ function lineageCliCanDelegateMutation(command, args) {
   if (command === "link-child") return true;
   if (command === "generate") return positions[0] === "image" && ["plan", "import"].includes(positions[1] || "");
   if (command === "reroll") return ["mark", "cancel", "plan", "import"].includes(subcommand);
+  if (command === "social") return ["mark", "unmark"].includes(subcommand);
   if (command === "tasks") return ["claim", "start", "comment", "cancel", "override", "instructions"].includes(subcommand);
   if (command === "agent") return ["claim", "heartbeat", "release", "revoke", "transfer"].includes(subcommand);
   return false;
@@ -10379,6 +10714,7 @@ app.get(
 );
 registerLineageWorkspaceRoutes(app, projectFrom, asyncRoute);
 registerLineageTaskRoutes(app, projectFrom, asyncRoute);
+registerAssetSocialMarkRoutes(app, projectFrom, asyncRoute);
 app.get("/api/lineage/:rootAssetId/rerolls", asyncRoute((req, res) => {
   res.json(listLineageRerollRequests(projectFrom(req), req.params.rootAssetId));
 }));
@@ -10630,7 +10966,7 @@ app.post(
 );
 if (isProduction) {
   const dist = join14(packageRoot, "dist", "web");
-  if (existsSync14(dist)) {
+  if (existsSync15(dist)) {
     app.use(express2.static(dist));
     app.get("*", (_req, res) => res.sendFile(join14(dist, "index.html")));
   }