@mean-weasel/lineage 0.1.7 → 0.1.8

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.8
+
+- Add durable selection packet export so agents can hand selected Lineage assets to GrowthOps without scraping UI state or copying local paths.
+- Add Agent OS adoption guidance for Lineage agents and operators.
+- Improve popover media previews, node actions, and image expansion controls for faster asset inspection.
+- Clean up the Lineage shell navigation, toolbar, and side-panel layout for a more focused workspace.
+
 ## 0.1.7
 
 - Add a claim-aware lineage task queue for per-image iteration and re-roll work, including task instructions, comments, cancellation, and human override controls.

package/README.md

@@ -60,6 +60,20 @@ Agents can inspect the current lineage graph without a claim:
 lineage agent graph --project demo-project --root <root-asset-id> --json
 ```
 
+Agents can also export the current active workspace selection as a durable JSON
+packet for downstream tools such as GrowthOps:
+
+```bash
+lineage selection packet --project demo-project --channel linkedin --campaign 2026-07-launch --out ./lineage-selection-packet.json --json
+```
+
+The packet is schema-versioned as `lineage.selection_packet.v1` and includes the
+workspace/root binding, selected asset IDs, local media paths when known, S3 key
+metadata when known, context labels/notes, warnings, and a stable `packet_id`.
+Lineage only exports the packet. GrowthOps or another downstream tool remains
+responsible for importing it, creating posts, checking media readiness, preparing
+public URLs, scheduling, and recording placement receipts.
+
 Keep the claim fresh and pass it to mutating commands:
 
 ```bash

package/dist/cli/lineage-dev.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli/lineageCli.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir, platform } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve4 } from "node:path";
+import { dirname as dirname3, join as join6, resolve as resolve5 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -328,6 +328,13 @@ function catalogPath(project = defaultProject) {
 function fixtureCatalogPath(project = defaultProject) {
   return join3(repoRoot, "fixtures", cleanProject(project), "assets", "catalog.json");
 }
+function resolvedCatalogPath(project = defaultProject) {
+  const path = catalogPath(project);
+  if (existsSync3(path)) return path;
+  const clean = cleanProject(project);
+  if (clean === defaultProject && existsSync3(fixtureCatalogPath(clean))) return fixtureCatalogPath(clean);
+  return path;
+}
 function normalizeCatalog(catalog, fallbackProject = defaultProject) {
   const project = cleanProject(catalog.project || catalog.product || fallbackProject);
   const product = catalog.product || project;
@@ -570,6 +577,10 @@ function listAssets(project = defaultProject, options = {}) {
     error
   };
 }
+function validateProject(project = defaultProject) {
+  const catalog = loadCatalog(project);
+  return { project: catalog.project, product: catalog.product, catalogPath: resolvedCatalogPath(project), default_bucket: catalog.default_bucket, default_region: catalog.default_region, asset_count: catalog.assets.length };
+}
 
 // src/server/assetLineageDb.ts
 var require2 = createRequire(import.meta.url);
@@ -2223,6 +2234,17 @@ function seedLegacyWorkspaces(database, project) {
     );
   }
 }
+function listRows(database, project) {
+  return database.prepare(`
+    select * from lineage_workspaces
+    where project_id = ?
+    order by
+      case status when 'active' then 0 when 'paused' then 1 else 2 end,
+      active_at desc nulls last,
+      updated_at desc,
+      title
+  `).all(project).map(rowToWorkspace);
+}
 function activeWorkspace(database, project) {
   const row = database.prepare(`
     select * from lineage_workspaces
@@ -2232,6 +2254,20 @@ function activeWorkspace(database, project) {
   `).get(project);
   return row ? rowToWorkspace(row) : null;
 }
+function listLineageWorkspaces(project) {
+  const database = lineageDb();
+  try {
+    seedLegacyWorkspaces(database, project);
+    return {
+      project,
+      active_workspace: activeWorkspace(database, project),
+      workspaces: listRows(database, project),
+      fetchedAt: nowIso()
+    };
+  } finally {
+    database.close();
+  }
+}
 function activeLineageWorkspaceRoot(project) {
   const database = lineageDb();
   try {
@@ -3336,13 +3372,234 @@ function importImageRerollOutput(project = defaultProject, fields) {
   }
 }
 
+// src/server/lineageSelectionPacket.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync5, statSync as statSync4 } from "node:fs";
+import { isAbsolute, resolve as resolve4 } from "node:path";
+var LineageSelectionPacketError = class extends Error {
+  constructor(message, warnings = [], errors = []) {
+    super(message);
+    this.warnings = warnings;
+    this.errors = errors;
+  }
+  warnings;
+  errors;
+};
+function listAllAssets(project) {
+  const pageSize = 100;
+  const first = listAssets(project, { page: 1, pageSize, source: "all" });
+  const assets = [...first.assets];
+  for (let page = 2; page <= first.pagination.totalPages; page += 1) {
+    assets.push(...listAssets(project, { page, pageSize, source: "all" }).assets);
+  }
+  return assets;
+}
+function resolveWorkspace(project, options) {
+  if (options.rootAssetId && options.workspaceId) {
+    throw new LineageSelectionPacketError("Use either --root or --workspace, not both.", [], ["ambiguous_workspace"]);
+  }
+  const snapshot = listLineageWorkspaces(project);
+  const target = options.workspaceId || options.rootAssetId;
+  const workspace = target ? snapshot.workspaces.find((item) => item.id === target || item.root_asset_id === target) : snapshot.active_workspace;
+  if (workspace) return workspace;
+  if (options.rootAssetId) {
+    return {
+      id: lineageWorkspaceId(project, options.rootAssetId),
+      project,
+      root_asset_id: options.rootAssetId,
+      title: `${options.rootAssetId} lineage`,
+      status: "active",
+      created_by: "system",
+      created_at: "",
+      updated_at: ""
+    };
+  }
+  const message = options.workspaceId ? `Unknown lineage workspace: ${options.workspaceId}` : "No active lineage workspace. Pass --root or activate a workspace first.";
+  throw new LineageSelectionPacketError(message, [], [options.workspaceId ? "unknown_workspace" : "missing_active_workspace"]);
+}
+function resolveLocalReference(reference) {
+  if (!reference) return void 0;
+  if (isAbsolute(reference)) return reference;
+  const repoRelative = resolve4(repoRoot, reference);
+  if (existsSync5(repoRelative)) return repoRelative;
+  return resolve4(repoRoot, ".asset-scratch", reference);
+}
+function fileSize(path) {
+  if (!path || !existsSync5(path)) return void 0;
+  try {
+    return statSync4(path).size;
+  } catch {
+    return void 0;
+  }
+}
+function storageState(hasLocal, hasS3) {
+  if (hasLocal && hasS3) return "local_and_s3";
+  if (hasLocal) return "local_only";
+  if (hasS3) return "s3_backed";
+  return "unresolved";
+}
+function currentAttemptFor(node) {
+  if (!node.current_attempt) return void 0;
+  return {
+    asset_id: node.current_attempt.asset_id,
+    checksum_sha256: node.current_attempt.checksum_sha256,
+    file_path: node.current_attempt.file_path,
+    generation_job_id: node.current_attempt.generation_job_id,
+    id: node.current_attempt.id,
+    is_current: node.current_attempt.is_current,
+    source: node.current_attempt.source
+  };
+}
+function assetForNode(node, catalogAsset, warnings) {
+  const localReference = catalogAsset?.local?.absolute_path || node.current_attempt?.file_path || node.local_path || catalogAsset?.local?.relative_path;
+  const absolutePath = catalogAsset?.local?.absolute_path || resolveLocalReference(localReference);
+  const localExists = absolutePath ? existsSync5(absolutePath) : false;
+  const hasLocalClaim = Boolean(absolutePath || node.local_path || catalogAsset?.local?.relative_path);
+  const s3Key = catalogAsset?.s3?.key || node.s3_key;
+  const hasS3 = Boolean(s3Key);
+  const checksum = catalogAsset?.local?.checksum_sha256 || node.current_attempt?.checksum_sha256 || node.checksum_sha256 || catalogAsset?.s3?.checksum_sha256;
+  const mimeType = catalogAsset?.local?.content_type || catalogAsset?.s3?.content_type;
+  const mediaType = catalogAsset?.content_type || node.media_type;
+  if (hasLocalClaim && !localExists) warnings.push(`Selected asset ${node.asset_id} has a local path but the file is missing: ${absolutePath || node.local_path}`);
+  if (!hasLocalClaim && !hasS3) warnings.push(`Selected asset ${node.asset_id} has neither a local file nor S3 key.`);
+  if (mediaType && mediaType !== "image" && mediaType !== "gif") warnings.push(`Selected asset ${node.asset_id} is ${mediaType}, not an image/gif asset.`);
+  return {
+    asset_id: node.asset_id,
+    campaign: catalogAsset?.campaign || node.campaign,
+    channel: catalogAsset?.channel || node.channel,
+    checksum_sha256: checksum,
+    current_attempt: currentAttemptFor(node),
+    local: {
+      absolute_path: absolutePath,
+      content_type: catalogAsset?.local?.content_type,
+      exists: localExists,
+      relative_path: catalogAsset?.local?.relative_path || node.local_path || node.current_attempt?.file_path,
+      size_bytes: catalogAsset?.local?.size_bytes || fileSize(absolutePath)
+    },
+    media_type: mediaType,
+    mime_type: mimeType,
+    review_notes: node.review_notes,
+    review_state: node.review_state,
+    s3: {
+      bucket: catalogAsset?.s3?.bucket,
+      checksum_sha256: catalogAsset?.s3?.checksum_sha256,
+      content_type: catalogAsset?.s3?.content_type,
+      etag: catalogAsset?.s3?.etag,
+      key: s3Key,
+      region: catalogAsset?.s3?.region,
+      size_bytes: catalogAsset?.s3?.size_bytes,
+      version_id: catalogAsset?.s3?.version_id
+    },
+    selection_note: node.selection_note,
+    source: catalogAsset?.source || node.source,
+    status: catalogAsset?.status || node.status,
+    storage_state: storageState(hasLocalClaim, hasS3),
+    title: catalogAsset?.title || node.title || node.asset_id
+  };
+}
+function packetId(packetIdentity) {
+  const digest = createHash3("sha256").update(JSON.stringify(packetIdentity)).digest("hex").slice(0, 24);
+  return `lineage_packet_${digest}`;
+}
+function getLineageSelectionPacket(project, options = {}) {
+  const workspace = resolveWorkspace(project, options);
+  const snapshot = getLineageSnapshot(project, workspace.root_asset_id);
+  const catalogSummary = validateProject(project);
+  const catalogAssets = listAllAssets(project);
+  const catalogById = new Map(catalogAssets.map((asset) => [asset.asset_id, asset]));
+  const warnings = [];
+  const errors = [];
+  const nodeById = new Map(snapshot.nodes.map((node) => [node.asset_id, node]));
+  const selectedItems = snapshot.selections.map((selection) => ({
+    asset_id: selection.asset_id,
+    position: selection.position,
+    selected_at: selection.selected_at,
+    selection_note: selection.notes
+  }));
+  if (selectedItems.length === 0) warnings.push(`Lineage workspace ${workspace.id} has no selected assets.`);
+  const assets = selectedItems.flatMap((item) => {
+    const node = nodeById.get(item.asset_id);
+    if (!node) {
+      const message = `Selected asset ${item.asset_id} is not present in the resolved workspace snapshot.`;
+      warnings.push(message);
+      errors.push("selected_asset_outside_workspace");
+      return [];
+    }
+    return [assetForNode(node, catalogById.get(item.asset_id), warnings)];
+  });
+  if (assets.some((asset) => !asset.dimensions)) warnings.push("Image dimensions are unavailable for one or more selected assets.");
+  if (options.strict) {
+    const strictErrors = [
+      ...selectedItems.length === 0 ? ["empty_selection"] : [],
+      ...assets.filter((asset) => asset.local.absolute_path && !asset.local.exists).map((asset) => `missing_local_file:${asset.asset_id}`),
+      ...errors
+    ];
+    if (strictErrors.length > 0) {
+      throw new LineageSelectionPacketError(`Lineage selection packet strict mode failed: ${strictErrors.join(", ")}`, warnings, strictErrors);
+    }
+  }
+  const context = {
+    campaign: options.campaign,
+    channel: options.channel,
+    labels: options.labels || [],
+    notes: options.contextNotes
+  };
+  const identity = {
+    assets: assets.map((asset) => ({
+      asset_id: asset.asset_id,
+      checksum_sha256: asset.checksum_sha256,
+      local_path: asset.local.absolute_path,
+      s3_key: asset.s3.key,
+      storage_state: asset.storage_state
+    })),
+    context,
+    project,
+    root_asset_id: workspace.root_asset_id,
+    schema_version: "lineage.selection_packet.v1",
+    selection: selectedItems,
+    workspace_id: workspace.id
+  };
+  return {
+    assets,
+    context,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    errors,
+    kind: "lineage.selection_packet",
+    packet_id: packetId(identity),
+    product: catalogSummary.product,
+    project,
+    schema_version: "lineage.selection_packet.v1",
+    selection: {
+      asset_ids: selectedItems.map((item) => item.asset_id),
+      count: selectedItems.length,
+      items: selectedItems,
+      root_asset_id: workspace.root_asset_id
+    },
+    source: {
+      app: "lineage",
+      command: options.command,
+      db_path: options.dbPath || process.env.LINEAGE_DB || lineageDbPath(),
+      package: options.packageVersion
+    },
+    warnings: [...new Set(warnings)],
+    workspace: {
+      active_at: workspace.active_at,
+      id: workspace.id,
+      notes: workspace.notes,
+      root_asset_id: workspace.root_asset_id,
+      status: workspace.status,
+      title: workspace.title
+    }
+  };
+}
+
 // src/cli/lineageCli.ts
 var signalExitCodes = {
   SIGINT: 130,
   SIGTERM: 143
 };
 function packageRoot() {
-  return resolve4(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
+  return resolve5(dirname3(fileURLToPath2(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
@@ -3366,6 +3623,19 @@ function readOption(args, name) {
   if (index >= 0) return args[index + 1];
   return void 0;
 }
+function readOptions(args, name) {
+  const values = [];
+  const prefix = `${name}=`;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length));
+    else if (arg === name && args[index + 1] && !args[index + 1].startsWith("--")) {
+      values.push(args[index + 1]);
+      index += 1;
+    }
+  }
+  return values;
+}
 function resolveStartOptions(config, args) {
   const runtimeDir = dataRoot(config.displayName);
   const rawPort = readOption(args, "--port") || process.env.PORT || String(config.defaultPort);
@@ -3389,6 +3659,7 @@ Usage:
   ${config.binName} next [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${config.binName} brief [--project <project>] [--root <asset-id>] [--db <path>] [--json]
   ${config.binName} inspect --asset-id <asset-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} selection packet [--project <project>] [--workspace <id-or-root>|--root <asset-id>] [--channel <channel>] [--campaign <campaign>] [--context-notes <text>] [--label <label>] [--out <path>] [--strict] [--db <path>] [--json]
   ${config.binName} link-child --root <asset-id> --child <asset-id> [--project <project>] [--claim-token <claim-id.secret>] [--confirm-write] [--db <path>] [--json]
   ${config.binName} reroll list --root <asset-id> [--project <project>] [--db <path>] [--json]
   ${config.binName} reroll mark --root <asset-id> --target <asset-id> [--notes <text>] [--requested-by agent|human|system] [--project <project>] [--confirm-write] [--db <path>] [--json]
@@ -3464,6 +3735,31 @@ function runLineageDataCommand(command, args) {
     if (!options.assetId) throw new Error("lineage inspect requires --asset-id");
     return getLineageSnapshot(options.project, options.assetId);
   }
+  if (command === "selection") {
+    const subcommand = positionalArgs(args)[0] || "";
+    if (subcommand !== "packet") throw new Error(`Unknown selection command: ${subcommand}`);
+    const labels = readOptions(args, "--label").flatMap((label) => label.split(",")).map((label) => label.trim()).filter(Boolean);
+    const packet = getLineageSelectionPacket(options.project, {
+      campaign: readOption(args, "--campaign"),
+      channel: readOption(args, "--channel"),
+      command: "lineage selection packet",
+      contextNotes: readOption(args, "--context-notes") || readOption(args, "--notes"),
+      dbPath: options.dbPath,
+      labels,
+      packageVersion: packageVersion(),
+      rootAssetId: options.rootAssetId,
+      strict: args.includes("--strict"),
+      workspaceId: readOption(args, "--workspace") || readOption(args, "--workspace-id")
+    });
+    const out = readOption(args, "--out");
+    if (out) {
+      const outPath = resolve5(out);
+      mkdirSync4(dirname3(outPath), { recursive: true });
+      writeFileSync2(outPath, `${JSON.stringify(packet, null, 2)}
+`);
+    }
+    return packet;
+  }
   if (command === "link-child") {
     if (!options.childAssetId) throw new Error("lineage link-child requires --child");
     return linkSelectedLineageChild(options.project, {
@@ -3613,6 +3909,13 @@ function printDataResult(command, result, json) {
     console.log(`Active: ${snapshot.active_asset_id}`);
     return;
   }
+  if (command === "selection" && result && typeof result === "object" && "packet_id" in result) {
+    const packet = result;
+    console.log(`${packet.packet_id}: ${packet.selection?.count || packet.assets?.length || 0} selected asset(s)`);
+    if (packet.workspace?.root_asset_id) console.log(`Root: ${packet.workspace.root_asset_id}`);
+    for (const warning of packet.warnings || []) console.log(`Warning: ${warning}`);
+    return;
+  }
   if (command === "link-child" && result && typeof result === "object") {
     const link = result;
     console.log(link.message || `${link.dryRun ? "Dry run: " : ""}Link ${link.edge?.child_asset_id || "child"} from ${link.edge?.parent_asset_id || "parent"}`);
@@ -3782,7 +4085,7 @@ function start(config, args) {
     process.exit(1);
   }
   const serverPath = join6(packageRoot(), "dist", "server.js");
-  if (!existsSync5(serverPath)) {
+  if (!existsSync6(serverPath)) {
     const message = `Missing bundled server at ${serverPath}. Run npm run build before using ${config.binName} start from a source checkout.`;
     if (options.json) console.error(JSON.stringify({ ok: false, error: message }, null, 2));
     else console.error(`${config.binName}: ${message}`);
@@ -3836,7 +4139,7 @@ function runLineageCli(config, args = process.argv.slice(2)) {
     start(config, normalizedArgs.slice(1));
     return;
   }
-  if (command === "next" || command === "brief" || command === "inspect" || command === "link-child" || command === "reroll" || command === "tasks") {
+  if (command === "next" || command === "brief" || command === "inspect" || command === "selection" || command === "link-child" || command === "reroll" || command === "tasks") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {