@mean-weasel/lineage 0.1.14 → 0.1.16

package/dist/cli/lineage-dev.js

@@ -8,6 +8,32 @@ import { dirname as dirname6, join as join10, resolve as resolve8 } from "node:p
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
+// src/shared/edgeSummary.ts
+var edgeSummaryWordLimit = 2;
+var EdgeSummaryValidationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EdgeSummaryValidationError";
+  }
+  code;
+};
+function normalizeEdgeSummary(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new EdgeSummaryValidationError("not_text", "Edge summary must be text");
+  const words = value.trim().split(/\s+/u).filter(Boolean);
+  if (words.length === 0) return void 0;
+  if (words.length > edgeSummaryWordLimit) {
+    throw new EdgeSummaryValidationError("too_many_words", `Edge summary must contain at most ${edgeSummaryWordLimit} words`);
+  }
+  return words.join(" ");
+}
+function requireEdgeSummary(value) {
+  const summary = normalizeEdgeSummary(value);
+  if (!summary) throw new EdgeSummaryValidationError("required", "Edge summary is required");
+  return summary;
+}
+
 // src/server/agentClaims.ts
 import { createHash as createHash4, randomBytes, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
@@ -17,7 +43,7 @@ import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "node:fs";
 import { join as join6 } from "node:path";
 
 // src/server/assetCore.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "node:fs";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -590,21 +616,26 @@ function validateProject(project = defaultProject) {
 
 // src/server/profileWriterLease.ts
 import { createHash as createHash3, randomUUID as randomUUID2, timingSafeEqual } from "node:crypto";
-import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { dirname as dirname4, join as join5, resolve as resolve4 } from "node:path";
 
 // src/server/lineageProfiles.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
+  closeSync,
   constants as fsConstants,
   copyFileSync as copyFileSync2,
   existsSync as existsSync4,
+  fsyncSync,
   linkSync,
+  lstatSync,
   mkdirSync as mkdirSync3,
+  openSync,
   readFileSync as readFileSync3,
   realpathSync,
+  renameSync,
   rmSync,
   statSync as statSync3,
   writeFileSync as writeFileSync2
@@ -617,6 +648,7 @@ var lineageProfileSchemaVersion = "lineage.profile.v1";
 var lineageProfileDoctorSchemaVersion = "lineage.profile_doctor.v1";
 var lineageProfileCloneReceiptSchemaVersion = "lineage.profile_clone_receipt.v1";
 var lineageProfileAssetsCloneReceiptSchemaVersion = "lineage.profile_assets_clone_receipt.v1";
+var lineageProfileRuntimeRepinReceiptSchemaVersion = "lineage.profile_runtime_repin_receipt.v1";
 
 // src/server/lineageProfiles.ts
 var require2 = createRequire(import.meta.url);
@@ -648,13 +680,13 @@ function profileManifestPath(selector) {
   if (!profileIdPattern.test(value)) throw new Error(`Invalid profile ID: ${value}`);
   return { manifestPath: join4(lineageProfileRoot(), value, "profile.json"), namedProfileId: value };
 }
-function requiredString(record, key) {
-  const value = record[key];
+function requiredString(record2, key) {
+  const value = record2[key];
   if (typeof value !== "string" || !value.trim()) throw new Error(`Profile manifest requires a non-empty ${key}`);
   return value.trim();
 }
-function optionalString(record, key) {
-  const value = record[key];
+function optionalString(record2, key) {
+  const value = record2[key];
   if (value === void 0) return void 0;
   if (typeof value !== "string" || !value.trim()) throw new Error(`Profile manifest ${key} must be a non-empty string`);
   return value.trim();
@@ -705,15 +737,15 @@ function resolveLineageProfile(selector) {
     throw new Error(`Could not parse profile manifest ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Profile manifest must be a JSON object");
-  const record = raw;
-  const schemaVersion = requiredString(record, "schema_version");
+  const record2 = raw;
+  const schemaVersion = requiredString(record2, "schema_version");
   if (schemaVersion !== lineageProfileSchemaVersion) throw new Error(`Unsupported profile schema_version: ${schemaVersion}`);
-  const profileId = requiredString(record, "profile_id");
+  const profileId = requiredString(record2, "profile_id");
   if (!profileIdPattern.test(profileId)) throw new Error(`Invalid profile ID: ${profileId}`);
   if (namedProfileId && namedProfileId !== profileId) {
     throw new Error(`Named profile ${namedProfileId} does not match immutable manifest profile_id ${profileId}`);
   }
-  const expectedRaw = record.expected_runtime;
+  const expectedRaw = record2.expected_runtime;
   if (expectedRaw !== void 0 && (!expectedRaw || typeof expectedRaw !== "object" || Array.isArray(expectedRaw))) {
     throw new Error("Profile expected_runtime must be an object");
   }
@@ -722,18 +754,18 @@ function resolveLineageProfile(selector) {
   const expectedVersion = expected ? optionalString(expected, "version") : void 0;
   const expectedCodeFingerprint = validateFingerprint(expected ? optionalString(expected, "code_fingerprint") : void 0, "expected_runtime.code_fingerprint");
   const expectedCodeOrigin = validateCodeOrigin(expected?.code_origin);
-  const migrationsRaw = record.required_schema_migrations;
+  const migrationsRaw = record2.required_schema_migrations;
   if (migrationsRaw !== void 0 && (!Array.isArray(migrationsRaw) || migrationsRaw.some((value) => typeof value !== "string" || !value.trim()))) {
     throw new Error("Profile required_schema_migrations must be an array of non-empty strings");
   }
-  const environment = validateEnvironment(requiredString(record, "environment"));
+  const environment = validateEnvironment(requiredString(record2, "environment"));
   const expectedChannel = validateChannel(expected?.channel);
   if (expectedChannel && expectedChannel !== environmentChannel(environment)) {
     throw new Error(`Profile environment ${environment} conflicts with expected runtime channel ${expectedChannel}`);
   }
   const manifest = {
-    asset_root: resolveManifestPath(manifestPath, requiredString(record, "asset_root")),
-    database_path: resolveManifestPath(manifestPath, requiredString(record, "database_path")),
+    asset_root: resolveManifestPath(manifestPath, requiredString(record2, "asset_root")),
+    database_path: resolveManifestPath(manifestPath, requiredString(record2, "database_path")),
     environment,
     ...expected ? {
       expected_runtime: {
@@ -747,7 +779,7 @@ function resolveLineageProfile(selector) {
     profile_id: profileId,
     ...migrationsRaw ? { required_schema_migrations: migrationsRaw.map((value) => value.trim()) } : {},
     schema_version: lineageProfileSchemaVersion,
-    service_origin: validateServiceOrigin(requiredString(record, "service_origin"))
+    service_origin: validateServiceOrigin(requiredString(record2, "service_origin"))
   };
   return { ...manifest, manifest_path: manifestPath, profile_fingerprint: lineageProfileFingerprint(manifest) };
 }
@@ -761,6 +793,129 @@ function lineageProfileFingerprint(profile) {
     service_origin: profile.service_origin
   })).digest("hex");
 }
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+function assertOwnerOnlyPath(path, kind) {
+  const stats = lstatSync(path);
+  const expectedType = kind === "manifest" ? stats.isFile() : stats.isDirectory();
+  if (!expectedType || stats.isSymbolicLink()) throw new Error(`Profile ${kind} must be a nonsymlink ${kind === "manifest" ? "regular file" : "directory"}: ${path}`);
+  if ((stats.mode & 63) !== 0) throw new Error(`Profile ${kind} must be owner-only: ${path}`);
+  if (typeof process.getuid === "function" && stats.uid !== process.getuid()) throw new Error(`Profile ${kind} must be owned by the current user: ${path}`);
+  return stats;
+}
+function runtimeRepinInvariant(profile) {
+  return JSON.stringify({
+    asset_root: profile.asset_root,
+    database_path: profile.database_path,
+    environment: profile.environment,
+    profile_fingerprint: profile.profile_fingerprint,
+    profile_id: profile.profile_id,
+    required_schema_migrations: profile.required_schema_migrations || [],
+    schema_version: profile.schema_version,
+    service_origin: profile.service_origin
+  });
+}
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+function repinLineageDevelopmentProfileRuntime(selector, checkoutRoot, runtime, confirmWrite) {
+  if (!confirmWrite) throw new Error("Profile runtime repin requires --confirm-write");
+  if (runtime.channel !== "dev") throw new Error(`Profile runtime repin requires dev code, not ${runtime.channel}`);
+  if (!runtime.code?.verified) throw new Error("Profile runtime repin requires a verified checkout runtime");
+  if (runtime.code.origin !== "checkout") throw new Error(`Profile runtime repin requires checkout code, not ${runtime.code.origin}`);
+  if (!runtime.code.fingerprint || !/^[a-f0-9]{64}$/i.test(runtime.code.fingerprint)) {
+    throw new Error("Profile runtime repin requires a valid executing code fingerprint");
+  }
+  if (!checkoutRoot.trim()) throw new Error("Profile runtime repin requires --checkout-root");
+  const intendedRoot = realpathSync(resolve3(checkoutRoot));
+  if (!statSync3(intendedRoot).isDirectory()) throw new Error(`Profile runtime repin checkout root is not a directory: ${intendedRoot}`);
+  const executingRoot = realpathSync(runtime.code.root);
+  if (intendedRoot !== executingRoot) {
+    throw new Error(`Profile runtime repin checkout root ${intendedRoot} does not match executing code root ${executingRoot}`);
+  }
+  const profile = resolveLineageProfile(selector);
+  if (profile.environment !== "development") throw new Error(`Profile runtime repin requires a development profile, not ${profile.environment}`);
+  if (profile.expected_runtime?.channel !== "dev") throw new Error("Development profile runtime repin requires an existing dev channel pin");
+  if (profile.expected_runtime.code_origin !== "checkout") throw new Error("Development profile runtime repin requires an existing checkout origin pin");
+  if (!profile.expected_runtime.code_fingerprint) throw new Error("Development profile runtime repin requires an existing code fingerprint pin");
+  const manifestPath = profile.manifest_path;
+  assertOwnerOnlyPath(dirname3(manifestPath), "profile directory");
+  const beforeStats = assertOwnerOnlyPath(manifestPath, "manifest");
+  const beforeText = readFileSync3(manifestPath, "utf8");
+  const beforeHash = sha256(beforeText);
+  let raw;
+  try {
+    raw = JSON.parse(beforeText);
+  } catch (error) {
+    throw new Error(`Could not parse profile manifest ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Profile manifest must be a JSON object");
+  const previousFingerprint = profile.expected_runtime.code_fingerprint;
+  const nextExpectedRuntime = {
+    channel: "dev",
+    code_fingerprint: runtime.code.fingerprint,
+    code_origin: "checkout",
+    ...runtime.gitSha ? { git_sha: runtime.gitSha } : {},
+    version: runtime.version
+  };
+  const updated = { ...raw, expected_runtime: nextExpectedRuntime };
+  const afterText = `${JSON.stringify(updated, null, 2)}
+`;
+  const afterHash = sha256(afterText);
+  const result = {
+    changed: beforeText !== afterText,
+    checkout_root: intendedRoot,
+    manifest_after_sha256: afterHash,
+    manifest_before_sha256: beforeHash,
+    manifest_path: manifestPath,
+    new_code_fingerprint: runtime.code.fingerprint,
+    previous_code_fingerprint: previousFingerprint,
+    profile_fingerprint: profile.profile_fingerprint,
+    profile_id: profile.profile_id,
+    schema_version: lineageProfileRuntimeRepinReceiptSchemaVersion
+  };
+  if (!result.changed) return result;
+  const temporaryPath = join4(dirname3(manifestPath), `.profile.runtime-repin-${randomUUID()}.tmp`);
+  let temporaryExists = false;
+  try {
+    writeFileSync2(temporaryPath, afterText, { encoding: "utf8", flag: "wx", mode: 384 });
+    temporaryExists = true;
+    chmodSync2(temporaryPath, 384);
+    const temporaryFd = openSync(temporaryPath, "r");
+    try {
+      fsyncSync(temporaryFd);
+    } finally {
+      closeSync(temporaryFd);
+    }
+    const preparedReplacement = resolveLineageProfile(temporaryPath);
+    if (runtimeRepinInvariant(preparedReplacement) !== runtimeRepinInvariant(profile)) {
+      throw new Error("Profile runtime repin would change immutable profile routing identity");
+    }
+    const currentStats = assertOwnerOnlyPath(manifestPath, "manifest");
+    const currentText = readFileSync3(manifestPath, "utf8");
+    if (!sameFileIdentity(beforeStats, currentStats) || sha256(currentText) !== beforeHash) {
+      throw new Error("Profile manifest changed while runtime repin was being prepared; refusing replacement");
+    }
+    renameSync(temporaryPath, manifestPath);
+    temporaryExists = false;
+    chmodSync2(manifestPath, 384);
+    const directoryFd = openSync(dirname3(manifestPath), "r");
+    try {
+      fsyncSync(directoryFd);
+    } finally {
+      closeSync(directoryFd);
+    }
+    const replacement = resolveLineageProfile(manifestPath);
+    if (runtimeRepinInvariant(replacement) !== runtimeRepinInvariant(profile)) {
+      throw new Error("Profile runtime repin changed immutable profile routing identity");
+    }
+    if (readFileSync3(manifestPath, "utf8") !== afterText) throw new Error("Profile runtime repin replacement bytes do not match the prepared manifest");
+    return result;
+  } finally {
+    if (temporaryExists) rmSync(temporaryPath, { force: true });
+  }
+}
 function assertProfileRuntimePin(profile, runtime) {
   if (!profile.expected_runtime?.code_fingerprint || !profile.expected_runtime.code_origin) {
     throw new Error(`Profile ${profile.profile_id} must pin expected_runtime.code_fingerprint and expected_runtime.code_origin before binding or writing`);
@@ -1051,6 +1206,7 @@ async function cloneLineageProfileDatabase(sourceDatabasePath, targetSelector, r
   const source = new DatabaseSync(sourcePath, { readOnly: true });
   try {
     const pagesCopied = await backup(source, temporaryPath);
+    chmodSync2(temporaryPath, 384);
     const cloned = new DatabaseSync(temporaryPath);
     let identity2;
     try {
@@ -1188,7 +1344,7 @@ function cloneLineageProfileAssets(sourceAssetRoot, targetSelector, runtime, con
       const destinationPath = join4(targetRoot, relativePath);
       mkdirSync3(dirname3(destinationPath), { recursive: true, mode: 448 });
       copyFileSync2(sourcePath, destinationPath, fsConstants.COPYFILE_EXCL);
-      chmodSync(destinationPath, 384);
+      chmodSync2(destinationPath, 384);
       const sourceHash = fileSha2562(sourcePath);
       const destinationHash = fileSha2562(destinationPath);
       if (sourceHash !== destinationHash) throw new Error("A source asset changed or failed checksum verification during clone");
@@ -1198,7 +1354,7 @@ function cloneLineageProfileAssets(sourceAssetRoot, targetSelector, runtime, con
       treeHash.update(destinationHash);
       treeHash.update("\0");
     }
-    chmodSync(targetRoot, 448);
+    chmodSync2(targetRoot, 448);
     const receiptPath = join4(targetRoot, ".lineage-profile-assets.json");
     const result = {
       asset_root: targetRoot,
@@ -1251,7 +1407,7 @@ function errorCode(error) {
   return error && typeof error === "object" && "code" in error ? String(error.code) : void 0;
 }
 function readOwner(lockPath) {
-  const stat = lstatSync(lockPath);
+  const stat = lstatSync2(lockPath);
   if (!stat.isDirectory() || stat.isSymbolicLink()) {
     throw new Error(`Writer lease path is not a safe directory: ${lockPath}; manual inspection is required`);
   }
@@ -1300,7 +1456,7 @@ function reclaimDeadOwner(lockPath, owner) {
   const tokenFence = createHash3("sha256").update(owner.token).digest("hex").slice(0, 24);
   const tombstone = `${lockPath}.stale-${owner.pid}-${tokenFence}`;
   try {
-    renameSync(lockPath, tombstone);
+    renameSync2(lockPath, tombstone);
   } catch (error) {
     if (errorCode(error) === "ENOENT") return;
     throw error;
@@ -1492,6 +1648,10 @@ function lineageDb() {
       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,
+      summary text,
+      summary_created_by text check (summary_created_by in ('human', 'agent', 'system')),
+      summary_updated_by text check (summary_updated_by in ('human', 'agent', 'system')),
+      summary_updated_at text,
       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);
@@ -1775,6 +1935,7 @@ function lineageDb() {
       imported_asset_id text not null references assets(id),
       parent_asset_id text not null references assets(id),
       imported_at text not null,
+      edge_summary text,
       unique(job_id, output_index),
       unique(job_id, file_path)
     );
@@ -1863,6 +2024,11 @@ function lineageDb() {
     );
     create index if not exists agent_claim_events_claim_created on agent_claim_events(claim_id, created_at);
   `);
+  ensureColumn(database, "asset_edges", "summary", "text");
+  ensureColumn(database, "asset_edges", "summary_created_by", "text check (summary_created_by in ('human', 'agent', 'system'))");
+  ensureColumn(database, "asset_edges", "summary_updated_by", "text check (summary_updated_by in ('human', 'agent', 'system'))");
+  ensureColumn(database, "asset_edges", "summary_updated_at", "text");
+  ensureColumn(database, "generation_job_outputs", "edge_summary", "text");
   migrateAssetSelections(database);
   dropLegacyAssetSelectionRootUnique(database);
   ensureColumn(database, "asset_selections", "notes", "text");
@@ -2988,6 +3154,14 @@ function cancelLineageTask(project, fields) {
     database.close();
   }
 }
+function cancelLineageIterateTasksForAssets(project, fields) {
+  const targetIds = fields.assetIds ? new Set(fields.assetIds) : void 0;
+  return listLineageTasks(project, fields.rootAssetId, ["pending"]).tasks.filter((task) => task.task_type === "iterate").filter((task) => !targetIds || targetIds.has(task.target_asset_id)).map((task) => cancelLineageTask(project, {
+    actor: fields.actor,
+    confirmWrite: fields.confirmWrite,
+    taskId: task.id
+  }));
+}
 function resolveLineageTask(project, fields) {
   const normalizedProject = normalizeProject(project);
   const actor = normalizeActor(fields.actor, "Resolve actor");
@@ -3353,6 +3527,23 @@ function rerollRequestId(project, root, node, timestamp) {
 function rowString(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
+function lineageEdgeFromRow(row) {
+  const summary = rowString(row.summary);
+  const summaryCreatedBy = rowString(row.summary_created_by);
+  const summaryUpdatedBy = rowString(row.summary_updated_by);
+  const summaryUpdatedAt = rowString(row.summary_updated_at);
+  return {
+    id: String(row.id),
+    parent_asset_id: String(row.parent_asset_id),
+    child_asset_id: String(row.child_asset_id),
+    relation_type: row.relation_type,
+    created_at: String(row.created_at),
+    ...summary ? { summary } : {},
+    ...summaryCreatedBy ? { summary_created_by: summaryCreatedBy } : {},
+    ...summaryUpdatedBy ? { summary_updated_by: summaryUpdatedBy } : {},
+    ...summaryUpdatedAt ? { summary_updated_at: summaryUpdatedAt } : {}
+  };
+}
 function rerollRequestFrom(row) {
   return {
     id: String(row.id),
@@ -3452,6 +3643,9 @@ function localPreviewUrl(project, localPath) {
   return `/api/assets/local-preview?${params.toString()}`;
 }
 function linkLineageAssets(project, fields) {
+  const summary = normalizeEdgeSummary(fields.summary);
+  if (summary && !fields.summaryActor) throw new LineageError("Lineage edge summary requires an explicit author");
+  if (!summary && fields.summaryActor) throw new LineageError("Lineage edge summary author requires a summary");
   const database = lineageDb();
   requireAsset2(database, project, fields.parentAssetId);
   requireAsset2(database, project, fields.childAssetId);
@@ -3470,22 +3664,66 @@ function linkLineageAssets(project, fields) {
     database.close();
     throw error;
   }
+  const createdAt = nowIso();
   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()
+    created_at: createdAt,
+    ...summary ? {
+      summary,
+      summary_created_by: fields.summaryActor,
+      summary_updated_by: fields.summaryActor,
+      summary_updated_at: createdAt
+    } : {}
   };
   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', ?)
+  const inserted = database.prepare(`
+    insert into asset_edges (
+      id, project_id, parent_asset_id, child_asset_id, relation_type, created_at,
+      summary, summary_created_by, summary_updated_by, summary_updated_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);
+  `).run(
+    edge.id,
+    project,
+    edge.parent_asset_id,
+    edge.child_asset_id,
+    edge.created_at,
+    edge.summary || null,
+    edge.summary_created_by || null,
+    edge.summary_updated_by || null,
+    edge.summary_updated_at || null
+  );
+  if (inserted.changes === 0) {
+    const existingRow = database.prepare(`
+      select id, parent_asset_id, child_asset_id, relation_type, created_at,
+        summary, summary_created_by, summary_updated_by, summary_updated_at
+      from asset_edges
+      where project_id = ? and parent_asset_id = ? and child_asset_id = ? and relation_type = 'derived_from'
+    `).get(project, edge.parent_asset_id, edge.child_asset_id);
+    if (!existingRow) {
+      database.close();
+      throw new LineageError("Lineage edge conflict could not be resolved", 409);
+    }
+    const existingEdge = lineageEdgeFromRow(existingRow);
+    if (summary && (existingEdge.summary !== summary || existingEdge.summary_created_by !== fields.summaryActor || existingEdge.summary_updated_by !== fields.summaryActor || !existingEdge.summary_updated_at)) {
+      database.close();
+      throw new LineageError("Lineage edge already exists with a different summary or provenance", 409);
+    }
+    database.close();
+    return {
+      ok: true,
+      idempotent: true,
+      message: `Already linked ${existingEdge.child_asset_id} from ${existingEdge.parent_asset_id}`,
+      edge: existingEdge
+    };
+  }
   database.close();
   return { ok: true, message: `Linked ${edge.child_asset_id} from ${edge.parent_asset_id}`, edge };
 }
@@ -3497,7 +3735,13 @@ function descendants(database, project, root) {
     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);
+    const rows = database.prepare(`
+      select id, parent_asset_id, child_asset_id, relation_type, created_at,
+        summary, summary_created_by, summary_updated_by, summary_updated_at
+      from asset_edges
+      where project_id = ? and parent_asset_id = ?
+      order by created_at
+    `).all(project, parent).map(lineageEdgeFromRow);
     edges.push(...rows);
     queue.push(...rows.map((row) => row.child_asset_id));
   }
@@ -3883,7 +4127,7 @@ function lineageCommand(command, project, rootAssetId) {
   return `${lineagePublicPackageCommand()} ${command} --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} ${lineageRuntimeSelector()} --json`;
 }
 function linkChildCommand(project, rootAssetId) {
-  return `${lineagePublicPackageCommand()} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --confirm-write ${lineageRuntimeSelector()} --json`;
+  return `${lineagePublicPackageCommand()} link-child --project ${shellQuote(project)} --root ${shellQuote(rootAssetId)} --child <asset-id> --summary "<one-or-two-words>" --confirm-write ${lineageRuntimeSelector()} --json`;
 }
 function rerollImportGuidance(rootAssetId, targetAssetId) {
   return `Use lineage reroll plan --root ${rootAssetId} --target ${targetAssetId} and lineage reroll import instead.`;
@@ -3932,6 +4176,7 @@ function getLineageBrief(project, rootAssetId) {
   };
 }
 function linkSelectedLineageChild(project, fields) {
+  const summary = fields.summaryActor ? requireEdgeSummary(fields.summary) : fields.summary;
   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 rerollRequests = listLineageRerollRequests(project, next.root_asset_id).requests;
@@ -3960,7 +4205,9 @@ function linkSelectedLineageChild(project, fields) {
     childAssetId: fields.childAssetId,
     confirmWrite: fields.confirmWrite,
     claimToken: fields.claimToken,
-    parentAssetId: next.next_asset.asset_id
+    parentAssetId: next.next_asset.asset_id,
+    summary,
+    summaryActor: fields.summaryActor
   });
   return {
     ...result,
@@ -3980,7 +4227,141 @@ function linkSelectedLineageChild(project, fields) {
 import { existsSync as existsSync8, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
 import { relative as relative3, resolve as resolve5 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
-var adapterVersion = "generation-receipts-v1";
+
+// src/shared/generationOutputManifest.ts
+var generationOutputManifestSchemaVersion = "lineage.generation_output_manifest.v1";
+var GenerationOutputManifestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationOutputManifestError";
+  }
+};
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new GenerationOutputManifestError(`${label} must be an object`);
+  }
+  return value;
+}
+function exactKeys(value, allowed, label) {
+  const allowedKeys = new Set(allowed);
+  const unsupported = Object.keys(value).filter((key) => !allowedKeys.has(key)).sort();
+  if (unsupported.length > 0) {
+    throw new GenerationOutputManifestError(`${label} contains unsupported field: ${unsupported[0]}`);
+  }
+}
+function nonEmptyText(value, label) {
+  if (typeof value !== "string" || !value.trim()) throw new GenerationOutputManifestError(`${label} is required`);
+  return value.trim();
+}
+function expectedGenerationOutputParents(job) {
+  if (!Number.isInteger(job.expected_output_count) || job.expected_output_count <= 0) {
+    throw new GenerationOutputManifestError("Generation job expected output count must be a positive integer");
+  }
+  const parents = job.inputs.filter((input) => input.role === "lineage_next_base").sort((left, right) => left.position - right.position);
+  if (parents.length === 0) throw new GenerationOutputManifestError("Generation job has no lineage_next_base input");
+  const parentIds = /* @__PURE__ */ new Set();
+  const parentPositions = /* @__PURE__ */ new Set();
+  for (const parent of parents) {
+    if (typeof parent.asset_id !== "string" || !parent.asset_id || parent.asset_id.trim() !== parent.asset_id) {
+      throw new GenerationOutputManifestError("Generation job has invalid lineage parent asset id");
+    }
+    if (!Number.isInteger(parent.position) || parent.position < 0 || parentPositions.has(parent.position)) {
+      throw new GenerationOutputManifestError("Generation job has invalid lineage parent positions");
+    }
+    if (parentIds.has(parent.asset_id)) throw new GenerationOutputManifestError(`Generation job has duplicate lineage parent: ${parent.asset_id}`);
+    parentIds.add(parent.asset_id);
+    parentPositions.add(parent.position);
+  }
+  if (job.expected_output_count % parents.length !== 0) {
+    throw new GenerationOutputManifestError("Generation job has invalid parent mapping");
+  }
+  const outputsPerParent = job.expected_output_count / parents.length;
+  return Array.from({ length: job.expected_output_count }, (_value, outputIndex) => {
+    return parents[Math.floor(outputIndex / outputsPerParent)].asset_id;
+  });
+}
+function createGenerationOutputManifestDraft(job) {
+  return {
+    schema_version: generationOutputManifestSchemaVersion,
+    job_id: job.id,
+    outputs: expectedGenerationOutputParents(job).map((parentAssetId, outputIndex) => ({
+      output_index: outputIndex,
+      file_path: "",
+      parent_asset_id: parentAssetId,
+      edge_summary: ""
+    }))
+  };
+}
+function parseGenerationOutputManifest(value, job, options) {
+  if (!options || typeof options.resolveFilePath !== "function") {
+    throw new GenerationOutputManifestError("Generation output manifest requires a file-path resolver");
+  }
+  const manifest = record(value, "Generation output manifest");
+  exactKeys(manifest, ["schema_version", "job_id", "outputs"], "Generation output manifest");
+  if (manifest.schema_version !== generationOutputManifestSchemaVersion) {
+    throw new GenerationOutputManifestError(`Generation output manifest schema_version must be ${generationOutputManifestSchemaVersion}`);
+  }
+  if (manifest.job_id !== job.id) throw new GenerationOutputManifestError(`Generation output manifest job_id must be ${job.id}`);
+  if (!Array.isArray(manifest.outputs)) throw new GenerationOutputManifestError("Generation output manifest outputs must be an array");
+  const expectedParents = expectedGenerationOutputParents(job);
+  if (manifest.outputs.length !== expectedParents.length) {
+    throw new GenerationOutputManifestError(`Generation output manifest requires ${expectedParents.length} outputs, received ${manifest.outputs.length}`);
+  }
+  const seenIndexes = /* @__PURE__ */ new Set();
+  const outputs = manifest.outputs.map((value2, position) => {
+    const output = record(value2, `Generation output at position ${position}`);
+    exactKeys(output, ["output_index", "file_path", "parent_asset_id", "edge_summary"], `Generation output at position ${position}`);
+    const outputIndex = output.output_index;
+    if (!Number.isInteger(outputIndex) || Number(outputIndex) < 0) {
+      throw new GenerationOutputManifestError(`Generation output at position ${position} requires a non-negative integer output_index`);
+    }
+    const normalizedIndex = Number(outputIndex);
+    if (seenIndexes.has(normalizedIndex)) throw new GenerationOutputManifestError(`Duplicate generation output_index: ${normalizedIndex}`);
+    seenIndexes.add(normalizedIndex);
+    const expectedParent = expectedParents[normalizedIndex];
+    if (!expectedParent) throw new GenerationOutputManifestError(`Unknown generation output_index: ${normalizedIndex}`);
+    const filePath = nonEmptyText(output.file_path, `Generation output ${normalizedIndex} file_path`);
+    const parentAssetId = nonEmptyText(output.parent_asset_id, `Generation output ${normalizedIndex} parent_asset_id`);
+    if (parentAssetId !== expectedParent) {
+      throw new GenerationOutputManifestError(`Generation output ${normalizedIndex} must use parent_asset_id ${expectedParent}`);
+    }
+    let edgeSummary;
+    try {
+      edgeSummary = requireEdgeSummary(output.edge_summary);
+    } catch (error) {
+      if (error instanceof EdgeSummaryValidationError) {
+        throw new GenerationOutputManifestError(`Generation output ${normalizedIndex}: ${error.message}`);
+      }
+      throw error;
+    }
+    return {
+      output_index: normalizedIndex,
+      file_path: filePath,
+      parent_asset_id: parentAssetId,
+      edge_summary: edgeSummary
+    };
+  });
+  for (const outputIndex of expectedParents.keys()) {
+    if (!seenIndexes.has(outputIndex)) throw new GenerationOutputManifestError(`Missing generation output_index: ${outputIndex}`);
+  }
+  outputs.sort((left, right) => left.output_index - right.output_index);
+  const seenPaths = /* @__PURE__ */ new Set();
+  const resolvedOutputs = outputs.map((output) => {
+    const filePath = nonEmptyText(options.resolveFilePath(output.file_path), `Generation output ${output.output_index} resolved file_path`);
+    if (seenPaths.has(filePath)) throw new GenerationOutputManifestError(`Duplicate generation output file_path: ${filePath}`);
+    seenPaths.add(filePath);
+    return { ...output, file_path: filePath };
+  });
+  return {
+    schema_version: generationOutputManifestSchemaVersion,
+    job_id: job.id,
+    outputs: resolvedOutputs
+  };
+}
+
+// src/server/generationReceipts.ts
+var legacyAdapterVersion = "generation-receipts-v1";
+var manifestAdapterVersion = "generation-receipts-v2";
 var provider = "codex-handoff";
 var GenerationReceiptError = class extends Error {
   constructor(message, status = 400) {
@@ -3999,6 +4380,70 @@ function parseJson(value, fallback) {
   if (!value) return fallback;
   return JSON.parse(value);
 }
+function positiveInteger(value) {
+  return Number.isInteger(value) && Number(value) > 0;
+}
+function resolveLineageSelection(project) {
+  const rootAssetId = activeLineageWorkspaceRoot(project);
+  if (!rootAssetId) throw new GenerationReceiptError("No active lineage workspace for generation planning");
+  const next = getLineageNextAsset(project, rootAssetId);
+  if (!next.next_asset) throw new GenerationReceiptError(`No clear lineage next asset: ${next.reason}`);
+  if (next.strategy !== "selected") throw new GenerationReceiptError("Generation v1 requires an explicit selected lineage next base");
+  if (next.selection_mode !== "multiple" && next.selection?.asset_id !== next.next_asset.asset_id) throw new GenerationReceiptError("Generation v1 requires one explicit selected lineage next base");
+  return next;
+}
+function selectedParents(next) {
+  const parents = next.next_assets.length > 0 ? next.next_assets : next.next_asset ? [next.next_asset] : [];
+  if (parents.length === 0) throw new GenerationReceiptError("Missing lineage next base");
+  return parents;
+}
+function parentMappings(next, perBaseCount) {
+  return selectedParents(next).map((parent, parentIndex) => ({
+    parent,
+    output_indexes: Array.from({ length: perBaseCount }, (_value, index) => parentIndex * perBaseCount + index)
+  }));
+}
+function buildHandoff(project, id, prompt, count, perBaseCount, next, inputs) {
+  const parent = next.next_asset;
+  if (!parent) throw new GenerationReceiptError("Missing lineage next base");
+  const parents = parentMappings(next, perBaseCount);
+  const outputManifest = createGenerationOutputManifestDraft({ id, expected_output_count: count, inputs });
+  const importCommand = `${lineagePublicPackageCommand()} generate image import --project ${quote(project)} --job-id ${quote(id)} --manifest ${quote(".asset-scratch/generation-output-manifest.json")} --confirm-write ${lineageRuntimeSelector()} --json`;
+  return {
+    schema_version: "lineage.generation_handoff.v2",
+    provider,
+    project,
+    job_id: id,
+    prompt,
+    expected_output_count: count,
+    per_base_count: next.selection_mode === "multiple" ? perBaseCount : void 0,
+    lineage: {
+      root_asset_id: next.root_asset_id,
+      parent_asset_id: parent.asset_id,
+      selection_strategy: next.strategy,
+      parent_title: parent.title,
+      parent_local_path: parent.local_path,
+      parent_s3_key: parent.s3_key,
+      parents: parents.length > 1 ? parents.map((mapping) => ({
+        parent_asset_id: mapping.parent.asset_id,
+        parent_title: mapping.parent.title,
+        parent_local_path: mapping.parent.local_path,
+        parent_s3_key: mapping.parent.s3_key,
+        output_indexes: mapping.output_indexes
+      })) : void 0
+    },
+    instructions: [
+      "Use Codex image generation outside Lineage server code.",
+      "Write generated output files under .asset-scratch before import.",
+      "Do not call live provider APIs from the CLI or server.",
+      "Fill every output_manifest entry with its generated file path and a one- or two-word edge summary.",
+      "Import the completed manifest with --confirm-write to persist every lineage child."
+    ],
+    import_command: importCommand,
+    output_manifest: outputManifest,
+    guardrails: { live_generation: false, external_services: false, output_root: ".asset-scratch", confirm_write_required: true }
+  };
+}
 function buildRerollHandoff(project, id, prompt, rootAssetId, target, request) {
   const importCommand = `${lineagePublicPackageCommand()} reroll import --project ${quote(project)} --job-id ${quote(id)} --file <.asset-scratch-file> --confirm-write ${lineageRuntimeSelector()} --json`;
   return {
@@ -4027,6 +4472,19 @@ function buildRerollHandoff(project, id, prompt, rootAssetId, target, request) {
     guardrails: { live_generation: false, external_services: false, output_root: ".asset-scratch", confirm_write_required: true }
   };
 }
+function inputsFrom(jobIdValue, project, next) {
+  return selectedParents(next).map((parent, position) => ({
+    id: `${jobIdValue}:input:${position}`,
+    job_id: jobIdValue,
+    project_id: project,
+    asset_id: parent.asset_id,
+    root_asset_id: next.root_asset_id,
+    role: "lineage_next_base",
+    position,
+    selection_strategy: next.strategy,
+    selection_snapshot: next
+  }));
+}
 function receiptFrom(row) {
   return {
     id: String(row.id),
@@ -4039,6 +4497,7 @@ function receiptFrom(row) {
   };
 }
 function outputFrom(row) {
+  const edgeSummary = typeof row.edge_summary === "string" && row.edge_summary.length > 0 ? row.edge_summary : void 0;
   return {
     id: String(row.id),
     job_id: String(row.job_id),
@@ -4050,7 +4509,8 @@ function outputFrom(row) {
     content_type: String(row.content_type),
     imported_asset_id: String(row.imported_asset_id),
     parent_asset_id: String(row.parent_asset_id),
-    imported_at: String(row.imported_at)
+    imported_at: String(row.imported_at),
+    ...edgeSummary ? { edge_summary: edgeSummary } : {}
   };
 }
 function loadGenerationJob(database, project, id) {
@@ -4096,6 +4556,72 @@ function insertReceipt(database, id, type, command, payload) {
     values (?, ?, ?, 'ok', ?, ?, ?)
   `).run(`${id}:receipt:${type}:${Date.now()}`, id, type, command, JSON.stringify(payload), nowIso());
 }
+function planImageGeneration(project = defaultProject, fields) {
+  const prompt = fields.prompt.trim();
+  if (!prompt) throw new GenerationReceiptError("Missing --prompt");
+  if (!fields.fromLineageSelection) throw new GenerationReceiptError("Generation v1 requires --from-lineage-selection");
+  const next = resolveLineageSelection(project);
+  const parentCount = selectedParents(next).length;
+  if (parentCount > 1 && !positiveInteger(fields.perBaseCount)) throw new GenerationReceiptError("Multi-parent generation requires --per-base-count");
+  const perBaseCount = parentCount > 1 ? Number(fields.perBaseCount) : Number(fields.count ?? fields.perBaseCount);
+  const count = parentCount * perBaseCount;
+  if (!positiveInteger(perBaseCount)) throw new GenerationReceiptError("Generation count must be a positive integer");
+  if (fields.count !== void 0 && fields.count !== count) throw new GenerationReceiptError(`Generation count mismatch: expected ${count} from selected bases, received ${fields.count}`);
+  const id = jobId();
+  const inputs = inputsFrom(id, project, next);
+  const handoff = buildHandoff(project, id, prompt, count, perBaseCount, next, inputs);
+  const mappings = parentMappings(next, perBaseCount).map((mapping) => ({ parent_asset_id: mapping.parent.asset_id, output_indexes: mapping.output_indexes }));
+  const timestamp = nowIso();
+  const preview2 = {
+    id,
+    project_id: project,
+    provider,
+    adapter_version: manifestAdapterVersion,
+    source_mode: "lineage_selection",
+    root_asset_id: next.root_asset_id,
+    prompt,
+    expected_output_count: count,
+    status: "planned",
+    output_dir: ".asset-scratch",
+    handoff,
+    created_at: timestamp,
+    updated_at: timestamp,
+    inputs,
+    outputs: [],
+    receipts: [{
+      id: `${id}:receipt:plan:preview`,
+      job_id: id,
+      receipt_type: "plan",
+      status: "ok",
+      command: "generate image plan",
+      payload: { prompt, expected_output_count: count, per_base_count: parentCount > 1 ? perBaseCount : void 0, lineage: handoff.lineage, parent_mappings: mappings },
+      created_at: timestamp
+    }]
+  };
+  if (fields.dryRun) return { ok: true, command: "generate image plan", project, dryRun: true, wouldWrite: true, job: preview2 };
+  const database = lineageDb();
+  try {
+    database.exec("BEGIN IMMEDIATE");
+    try {
+      database.prepare(`
+        insert into generation_jobs (
+          id, project_id, provider, adapter_version, source_mode, root_asset_id, prompt,
+          expected_output_count, status, output_dir, handoff_json, created_at, updated_at
+        ) values (?, ?, ?, ?, 'lineage_selection', ?, ?, ?, 'planned', ?, ?, ?, ?)
+      `).run(id, project, provider, manifestAdapterVersion, next.root_asset_id, prompt, count, ".asset-scratch", JSON.stringify(handoff), timestamp, timestamp);
+      const insertInput = database.prepare("insert into generation_job_inputs (id, job_id, project_id, asset_id, root_asset_id, role, position, selection_strategy, selection_snapshot_json) values (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+      for (const input of inputs) insertInput.run(input.id, id, project, input.asset_id, input.root_asset_id, input.role, input.position, input.selection_strategy, JSON.stringify(next));
+      insertReceipt(database, id, "plan", "generate image plan", preview2.receipts[0].payload);
+      database.exec("COMMIT");
+    } catch (error) {
+      database.exec("ROLLBACK");
+      throw error;
+    }
+    return { ok: true, command: "generate image plan", project, job: loadGenerationJob(database, project, id) };
+  } finally {
+    database.close();
+  }
+}
 function planImageReroll(project = defaultProject, fields) {
   const prompt = fields.prompt.trim();
   if (!prompt) throw new GenerationReceiptError("Missing --prompt");
@@ -4140,7 +4666,7 @@ function planImageReroll(project = defaultProject, fields) {
     id,
     project_id: project,
     provider,
-    adapter_version: adapterVersion,
+    adapter_version: legacyAdapterVersion,
     source_mode: "lineage_reroll",
     root_asset_id: snapshot.root_asset_id,
     prompt,
@@ -4172,7 +4698,7 @@ function planImageReroll(project = defaultProject, fields) {
           id, project_id, provider, adapter_version, source_mode, root_asset_id, prompt,
           expected_output_count, status, output_dir, handoff_json, created_at, updated_at
         ) values (?, ?, ?, ?, 'lineage_reroll', ?, ?, 1, 'planned', ?, ?, ?, ?)
-      `).run(id, project, provider, adapterVersion, snapshot.root_asset_id, prompt, ".asset-scratch", JSON.stringify(handoff), timestamp, timestamp);
+      `).run(id, project, provider, legacyAdapterVersion, snapshot.root_asset_id, prompt, ".asset-scratch", JSON.stringify(handoff), timestamp, timestamp);
       database.prepare("insert into generation_job_inputs (id, job_id, project_id, asset_id, root_asset_id, role, position, selection_strategy, selection_snapshot_json) values (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(input.id, id, project, input.asset_id, input.root_asset_id, input.role, input.position, input.selection_strategy, JSON.stringify(input.selection_snapshot));
       insertReceipt(database, id, "plan", "reroll plan", preview2.receipts[0].payload);
       database.exec("COMMIT");
@@ -4185,14 +4711,66 @@ function planImageReroll(project = defaultProject, fields) {
     database.close();
   }
 }
+function parentForOutput(job, outputIndex) {
+  const inputs = job.inputs.filter((input) => input.role === "lineage_next_base");
+  if (inputs.length === 0) throw new GenerationReceiptError("Generation job has no lineage_next_base input");
+  if (inputs.length === 1) return inputs[0].asset_id;
+  if (job.expected_output_count % inputs.length !== 0) throw new GenerationReceiptError("Generation job has invalid parent mapping");
+  return inputs[Math.floor(outputIndex / (job.expected_output_count / inputs.length))]?.asset_id || inputs[inputs.length - 1].asset_id;
+}
+function parentInputs(job) {
+  const inputs = job.inputs.filter((input) => input.role === "lineage_next_base");
+  if (inputs.length === 0) throw new GenerationReceiptError("Generation job has no lineage_next_base input");
+  return inputs;
+}
+function parentFilesFor(job, parentFiles) {
+  const inputs = parentInputs(job);
+  const expectedPerParent = job.expected_output_count / inputs.length;
+  if (!Number.isInteger(expectedPerParent)) throw new GenerationReceiptError("Generation job has invalid parent mapping");
+  const allowedParents = new Set(inputs.map((input) => input.asset_id));
+  const seenParents = /* @__PURE__ */ new Set();
+  const mapped = [];
+  for (const parentAssetId of Object.keys(parentFiles)) {
+    if (!allowedParents.has(parentAssetId)) throw new GenerationReceiptError(`Unknown generation parent mapping: ${parentAssetId}`);
+    if (seenParents.has(parentAssetId)) throw new GenerationReceiptError(`Duplicate generation parent mapping: ${parentAssetId}`);
+    seenParents.add(parentAssetId);
+  }
+  for (const input of inputs) {
+    const files = (parentFiles[input.asset_id] || []).map((file) => file.trim()).filter(Boolean);
+    if (files.length === 0) throw new GenerationReceiptError(`Missing generation parent mapping for ${input.asset_id}`);
+    if (files.length !== expectedPerParent) throw new GenerationReceiptError(`Parent ${input.asset_id} requires ${expectedPerParent} output file${expectedPerParent === 1 ? "" : "s"}, received ${files.length}`);
+    for (const file of files) mapped.push({ file, parentAssetId: input.asset_id });
+  }
+  return mapped;
+}
+function orderedFilesFor(job, files) {
+  return files.map((file, index) => ({ file, parentAssetId: parentForOutput(job, index) }));
+}
+function inspectImageGeneration(project = defaultProject, jobIdValue) {
+  if (!jobIdValue) throw new GenerationReceiptError("Missing --job-id");
+  const database = lineageDb();
+  try {
+    return { ok: true, command: "generate image inspect", project, job: loadGenerationJob(database, project, jobIdValue) };
+  } finally {
+    database.close();
+  }
+}
 function isPathInside(child, parent) {
   const rel = relative3(parent, child);
   return Boolean(rel) && !rel.startsWith("..") && !rel.startsWith("/");
 }
-function resolveScratchFile(file) {
+function scratchCandidate(file) {
   const scratchRoot = resolve5(repoRoot, ".asset-scratch");
   const candidate = file.startsWith(".asset-scratch/") || resolve5(file).startsWith(scratchRoot) ? resolve5(repoRoot, file) : resolve5(scratchRoot, file);
   if (!isPathInside(candidate, scratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
+  return { candidate, scratchRoot };
+}
+function resolveScratchManifestPath(file) {
+  const { candidate, scratchRoot } = scratchCandidate(file);
+  return relative3(scratchRoot, candidate);
+}
+function resolveScratchFile(file) {
+  const { candidate, scratchRoot } = scratchCandidate(file);
   if (!existsSync8(candidate)) throw new GenerationReceiptError(`Missing import file: ${file}`, 404);
   const realScratchRoot = realpathSync2(scratchRoot);
   const realCandidate = realpathSync2(candidate);
@@ -4208,6 +4786,165 @@ function resolveScratchFile(file) {
     assetId: `local-${checksum.slice(0, 12)}`
   };
 }
+function generationManifestConflict() {
+  throw new GenerationReceiptError("Generation import already exists with different output, summary, or provenance", 409);
+}
+function confirmManifestRetry(project, job, manifest) {
+  if (job.outputs.length !== manifest.outputs.length) generationManifestConflict();
+  const database = lineageDb();
+  try {
+    for (const expected of manifest.outputs) {
+      const recorded = job.outputs.find((output) => output.output_index === expected.output_index);
+      if (!recorded || recorded.file_path !== expected.file_path || recorded.parent_asset_id !== expected.parent_asset_id || recorded.edge_summary !== expected.edge_summary) generationManifestConflict();
+      const edge = database.prepare(`
+        select summary, summary_created_by, summary_updated_by, summary_updated_at
+        from asset_edges
+        where project_id = ? and parent_asset_id = ? and child_asset_id = ? and relation_type = 'derived_from'
+      `).get(project, recorded.parent_asset_id, recorded.imported_asset_id);
+      if (!edge || edge.summary !== expected.edge_summary || edge.summary_created_by !== "agent" || edge.summary_updated_by !== "agent" || typeof edge.summary_updated_at !== "string" || edge.summary_updated_at.length === 0) generationManifestConflict();
+    }
+    return { ok: true, command: "generate image import", project, job, imported: job.outputs, idempotent: true };
+  } finally {
+    database.close();
+  }
+}
+function importImageGenerationOutputs(project = defaultProject, fields) {
+  if (!fields.jobId) throw new GenerationReceiptError("Missing --job-id");
+  if (!fields.confirmWrite) throw new GenerationReceiptError("Generation import requires --confirm-write");
+  const database = lineageDb();
+  let job;
+  try {
+    job = loadGenerationJob(database, project, fields.jobId);
+  } finally {
+    database.close();
+  }
+  if (job.source_mode !== "lineage_selection") throw new GenerationReceiptError(`Generation job is not an image-selection job: ${job.source_mode}`);
+  const hasManifestInput = fields.manifest !== void 0;
+  const hasParentFilesInput = fields.parentFiles !== void 0;
+  const hasFilesInput = fields.files !== void 0;
+  if (hasManifestInput && (hasParentFilesInput || hasFilesInput)) {
+    throw new GenerationReceiptError("Use --manifest or legacy --files/--parent-files, not both");
+  }
+  if (hasParentFilesInput && hasFilesInput) throw new GenerationReceiptError("Use --files or --parent-files, not both");
+  let manifest;
+  let parentFileRows;
+  let mappingStrategy;
+  if (job.adapter_version === manifestAdapterVersion) {
+    if (!hasManifestInput) throw new GenerationReceiptError("New generation jobs require --manifest");
+    manifest = parseGenerationOutputManifest(fields.manifest, job, { resolveFilePath: resolveScratchManifestPath });
+    if (job.status === "imported") return confirmManifestRetry(project, job, manifest);
+    if (job.status !== "planned") throw new GenerationReceiptError(`Generation job is not importable from status: ${job.status}`);
+    parentFileRows = manifest.outputs.map((output) => ({
+      edgeSummary: output.edge_summary,
+      file: output.file_path,
+      parentAssetId: output.parent_asset_id
+    }));
+    mappingStrategy = "generation_output_manifest_v1";
+  } else if (job.adapter_version === legacyAdapterVersion) {
+    if (hasManifestInput) throw new GenerationReceiptError("Already-planned legacy generation jobs require --files or --parent-files");
+    if (job.status !== "planned") throw new GenerationReceiptError(`Generation job is not importable from status: ${job.status}`);
+    const hasExplicitParentFiles = Boolean(fields.parentFiles && Object.keys(fields.parentFiles).length > 0);
+    parentFileRows = hasExplicitParentFiles ? parentFilesFor(job, fields.parentFiles || {}) : orderedFilesFor(job, (fields.files || []).map((file) => file.trim()).filter(Boolean));
+    mappingStrategy = hasExplicitParentFiles ? "explicit_parent_files" : "ordered_per_base";
+  } else {
+    throw new GenerationReceiptError(`Unsupported generation adapter version: ${job.adapter_version}`);
+  }
+  if (parentFileRows.length === 0) throw new GenerationReceiptError("Generation import requires --files or --parent-files");
+  if (parentFileRows.length !== job.expected_output_count) {
+    throw new GenerationReceiptError(`Output count mismatch: expected ${job.expected_output_count}, received ${parentFileRows.length}`);
+  }
+  const resolved = parentFileRows.map((row) => ({ ...resolveScratchFile(row.file), edgeSummary: row.edgeSummary, parentAssetId: row.parentAssetId }));
+  const uniquePaths = new Set(resolved.map((file) => file.relativePath));
+  if (uniquePaths.size !== resolved.length) throw new GenerationReceiptError("Generation import files must be unique");
+  cancelLineageIterateTasksForAssets(project, {
+    actor: "system",
+    confirmWrite: false,
+    rootAssetId: job.root_asset_id
+  });
+  indexLineageAssets(project);
+  const writeDb = lineageDb();
+  try {
+    const timestamp = nowIso();
+    writeDb.exec("BEGIN IMMEDIATE");
+    try {
+      for (const [index, file] of resolved.entries()) {
+        const assetRow = writeDb.prepare("select id from assets where project_id = ? and id = ?").get(project, file.assetId);
+        if (!assetRow) throw new GenerationReceiptError(`Indexed local asset was not found: ${file.relativePath}`);
+        const outputId = `${fields.jobId}:output:${index}`;
+        writeDb.prepare(`insert into generation_job_outputs (
+          id, job_id, project_id, output_index, file_path, checksum_sha256, size_bytes, content_type,
+          imported_asset_id, parent_asset_id, imported_at, edge_summary
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+          outputId,
+          fields.jobId,
+          project,
+          index,
+          file.relativePath,
+          file.checksum,
+          file.size,
+          file.contentType,
+          file.assetId,
+          file.parentAssetId,
+          timestamp,
+          file.edgeSummary || null
+        );
+        const insertedEdge = writeDb.prepare(`insert into asset_edges (
+          id, project_id, parent_asset_id, child_asset_id, relation_type, created_at,
+          summary, summary_created_by, summary_updated_by, summary_updated_at
+        ) values (?, ?, ?, ?, 'derived_from', ?, ?, ?, ?, ?)
+        on conflict(project_id, parent_asset_id, child_asset_id, relation_type) do nothing`).run(
+          `${project}:${file.parentAssetId}:derived_from:${file.assetId}`,
+          project,
+          file.parentAssetId,
+          file.assetId,
+          timestamp,
+          file.edgeSummary || null,
+          file.edgeSummary ? "agent" : null,
+          file.edgeSummary ? "agent" : null,
+          file.edgeSummary ? timestamp : null
+        );
+        if (file.edgeSummary && insertedEdge.changes === 0) {
+          const edge = writeDb.prepare(`
+            select summary, summary_created_by, summary_updated_by, summary_updated_at
+            from asset_edges
+            where project_id = ? and parent_asset_id = ? and child_asset_id = ? and relation_type = 'derived_from'
+          `).get(project, file.parentAssetId, file.assetId);
+          if (!edge || edge.summary !== file.edgeSummary || edge.summary_created_by !== "agent" || edge.summary_updated_by !== "agent" || typeof edge.summary_updated_at !== "string" || edge.summary_updated_at.length === 0) generationManifestConflict();
+        }
+      }
+      writeDb.prepare(`
+        update generation_jobs
+        set status = 'imported', imported_at = ?, updated_at = ?
+        where project_id = ? and id = ?
+      `).run(timestamp, timestamp, project, fields.jobId);
+      insertReceipt(writeDb, fields.jobId, "import", "generate image import", {
+        mapping_strategy: mappingStrategy,
+        files: resolved.map((file, index) => ({
+          output_index: index,
+          file_path: file.relativePath,
+          imported_asset_id: file.assetId,
+          parent_asset_id: file.parentAssetId,
+          ...file.edgeSummary ? { edge_summary: file.edgeSummary } : {}
+        })),
+        selection_reset: { root_asset_id: job.root_asset_id, cleared: true }
+      });
+      writeDb.prepare("delete from asset_selections where project_id = ? and root_asset_id = ?").run(project, job.root_asset_id);
+      writeDb.exec("COMMIT");
+    } catch (error) {
+      writeDb.exec("ROLLBACK");
+      throw error;
+    }
+    cancelLineageIterateTasksForAssets(project, {
+      actor: "system",
+      confirmWrite: true,
+      rootAssetId: job.root_asset_id
+    });
+    const importedJob = loadGenerationJob(writeDb, project, fields.jobId);
+    return { ok: true, command: "generate image import", project, job: importedJob, imported: importedJob.outputs };
+  } finally {
+    writeDb.close();
+  }
+}
 function importImageRerollOutput(project = defaultProject, fields) {
   if (!fields.jobId) throw new GenerationReceiptError("Missing --job-id");
   if (!fields.confirmWrite) throw new GenerationReceiptError("Generation import requires --confirm-write");
@@ -4783,7 +5520,7 @@ function getLineageSelectionPacket(project, options = {}) {
 import { createHash as createHash6 } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createRequire as createRequire4 } from "node:module";
-import { existsSync as existsSync10, lstatSync as lstatSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, readlinkSync, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync10, lstatSync as lstatSync3, readFileSync as readFileSync5, readdirSync as readdirSync3, readlinkSync, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
 import { dirname as dirname5, isAbsolute as isAbsolute3, join as join9, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -4810,7 +5547,7 @@ function executingCodeRoot() {
   return canonicalRoot(root);
 }
 var codeRoot = executingCodeRoot();
-function sha256(value) {
+function sha2562(value) {
   return createHash6("sha256").update(value).digest("hex");
 }
 function canonicalRoot(root) {
@@ -4849,7 +5586,7 @@ function untrackedFingerprint(root, status) {
     hash.update(relativePath);
     const path = join9(root, relativePath);
     try {
-      const stat = lstatSync2(path);
+      const stat = lstatSync3(path);
       if (stat.isSymbolicLink()) hash.update(readlinkSync(path));
       else if (stat.isFile()) hash.update(readFileSync5(path));
       else hash.update(`[${stat.mode}:${stat.size}]`);
@@ -4871,12 +5608,12 @@ function checkoutCodeIdentity(root, channel, version) {
   if (status === void 0 || diff === void 0) errors.push("Checkout dirty state could not be inspected");
   if (channel !== "dev") errors.push(`Checkout code may run only as dev, not ${channel}`);
   const dirty = Boolean(status);
-  const sourceFingerprint = sha256(`${gitSha || "unknown"}\0${sha256(diff || "")}\0${untrackedFingerprint(root, status || "")}`);
+  const sourceFingerprint = sha2562(`${gitSha || "unknown"}\0${sha2562(diff || "")}\0${untrackedFingerprint(root, status || "")}`);
   return {
     channel,
     dirty,
     errors,
-    fingerprint: sha256(JSON.stringify({ channel, dirty, git_sha: gitSha, origin: "checkout", root, source_fingerprint: sourceFingerprint, version })),
+    fingerprint: sha2562(JSON.stringify({ channel, dirty, git_sha: gitSha, origin: "checkout", root, source_fingerprint: sourceFingerprint, version })),
     git_sha: gitSha,
     origin: "checkout",
     package_version: version,
@@ -4886,7 +5623,7 @@ function checkoutCodeIdentity(root, channel, version) {
   };
 }
 function buildFingerprint(build) {
-  return sha256(JSON.stringify({
+  return sha2562(JSON.stringify({
     package_name: build.package_name,
     package_version: build.package_version,
     schema_version: build.schema_version,
@@ -4986,7 +5723,7 @@ function packageCodeIdentity(root, channel, info, receiptPath) {
     channel,
     dirty: build?.source_dirty,
     errors,
-    fingerprint: sha256(JSON.stringify({
+    fingerprint: sha2562(JSON.stringify({
       build_fingerprint: build?.build_fingerprint,
       channel,
       install_integrity: install?.package_integrity,
@@ -5014,7 +5751,7 @@ function getLineageCodeIdentity(channel, options = {}) {
   return {
     channel,
     errors,
-    fingerprint: sha256(JSON.stringify({ channel, origin: "unknown", root, version: info.version })),
+    fingerprint: sha2562(JSON.stringify({ channel, origin: "unknown", root, version: info.version })),
     origin: "unknown",
     package_version: info.version,
     root,
@@ -5111,22 +5848,23 @@ var ManagedWriterRoutingError = class extends Error {
   status;
 };
 function managedWriterTimeoutMs(command, args) {
-  const subcommand = args.find((arg) => !arg.startsWith("-")) || "";
-  return command === "reroll" && subcommand === "import" ? 5 * 6e4 : 3e4;
+  const positions = args.filter((arg) => !arg.startsWith("-"));
+  const slowImport = command === "reroll" && positions[0] === "import" || command === "generate" && positions[0] === "image" && positions[1] === "import";
+  return slowImport ? 5 * 6e4 : 3e4;
 }
 function errorMessage(body, fallback) {
   if (!body || typeof body !== "object" || Array.isArray(body)) return fallback;
-  const record = body;
-  if (typeof record.message === "string") return record.message;
-  if (typeof record.error === "string") return record.error;
+  const record2 = body;
+  if (typeof record2.message === "string") return record2.message;
+  if (typeof record2.error === "string") return record2.error;
   return fallback;
 }
 function agentClaimError(body, status) {
   if (!body || typeof body !== "object" || Array.isArray(body)) return void 0;
-  const record = body;
-  if (typeof record.message !== "string" || typeof record.error !== "string") return void 0;
-  const conflicts = Array.isArray(record.conflicts) ? record.conflicts : [];
-  return new AgentClaimError(record.message, status, record.error, conflicts);
+  const record2 = body;
+  if (typeof record2.message !== "string" || typeof record2.error !== "string") return void 0;
+  const conflicts = Array.isArray(record2.conflicts) ? record2.conflicts : [];
+  return new AgentClaimError(record2.message, status, record2.error, conflicts);
 }
 function assertResponseIdentity(body, profile, channel) {
   if (!body || typeof body !== "object" || Array.isArray(body)) {
@@ -5224,6 +5962,26 @@ function readOptions(args, name) {
   }
   return values;
 }
+function readJsonFile(path, label) {
+  try {
+    return JSON.parse(readFileSync6(resolve8(path), "utf8"));
+  } catch (error) {
+    throw new Error(`${label} must be a readable JSON file: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function parentFilesOption(value) {
+  if (value === void 0) return void 0;
+  const mappings = {};
+  for (const rawMapping of value.split(";")) {
+    const separator = rawMapping.indexOf("=");
+    const parent = separator >= 0 ? rawMapping.slice(0, separator).trim() : "";
+    const files = separator >= 0 ? rawMapping.slice(separator + 1).split(",").map((file) => file.trim()).filter(Boolean) : [];
+    if (!parent || files.length === 0) throw new Error("lineage generate image import --parent-files requires parent=file[,file][;parent=file]");
+    if (Object.hasOwn(mappings, parent)) throw new Error(`Duplicate generation parent mapping: ${parent}`);
+    mappings[parent] = files;
+  }
+  return mappings;
+}
 function resolveStartOptions(config, args) {
   const profile = prepareCliProfile(config, args);
   const serviceUrl = profile ? new URL(profile.service_origin) : void 0;
@@ -5309,13 +6067,18 @@ Usage:
   ${config.binName} profile bind --profile <id-or-manifest> --confirm-write [--json]
   ${config.binName} profile clone --source-db <snapshot-source> --target-profile <id-or-manifest> --confirm-write [--json]
   ${config.binName} profile clone-assets --source-asset-root <path> --target-profile <id-or-manifest> --confirm-write [--json]
+  ${config.binName} profile repin-runtime --profile <development-profile> --checkout-root <path> --confirm-write [--json]
   ${config.binName} runtime info [--json]
   ${config.binName} runtime doctor [--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} selection packet [--project <project>] [--workspace <id-or-root>|--root <asset-id>] [--channel <channel>] [--campaign <campaign>] [--context-notes <text>] [--label <label>] [--schema v2] [--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} link-child --root <asset-id> --child <asset-id> --summary "<one-or-two-words>" [--project <project>] [--claim-token <claim-id.secret>] [--confirm-write] [--db <path>] [--json]
+  ${config.binName} generate image plan --prompt <text> --from-lineage-selection [--count <count>|--per-base-count <count>] [--project <project>] [--dry-run] [--db <path>] [--json]
+  ${config.binName} generate image inspect --job-id <job-id> [--project <project>] [--db <path>] [--json]
+  ${config.binName} generate image import --job-id <job-id> --manifest <json-file> --confirm-write [--project <project>] [--db <path>] [--json]
+  ${config.binName} generate image import --job-id <legacy-job-id> (--files <file,file>|--parent-files <parent=file;parent=file>) --confirm-write [--project <project>] [--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]
   ${config.binName} reroll cancel --root <asset-id> --target <asset-id> [--project <project>] [--confirm-write] [--db <path>] [--json]
@@ -5437,7 +6200,8 @@ function resolveDataCommandOptions(args) {
     dbPath: readOption(args, "--db"),
     json: args.includes("--json"),
     project: readOption(args, "--project") || process.env.LINEAGE_DEFAULT_PRODUCT || defaultProduct,
-    rootAssetId: readOption(args, "--root")
+    rootAssetId: readOption(args, "--root"),
+    summary: readOption(args, "--summary")
   };
   if (options.dbPath) process.env.LINEAGE_DB = options.dbPath;
   return options;
@@ -5480,13 +6244,57 @@ function runLineageDataCommand(command, args) {
   }
   if (command === "link-child") {
     if (!options.childAssetId) throw new Error("lineage link-child requires --child");
+    const summary = requireEdgeSummary(options.summary);
     return linkSelectedLineageChild(options.project, {
       childAssetId: options.childAssetId,
       claimToken: options.claimToken,
       confirmWrite: options.confirmWrite,
-      rootAssetId: options.rootAssetId || options.assetId
+      rootAssetId: options.rootAssetId || options.assetId,
+      summary,
+      summaryActor: "agent"
     });
   }
+  if (command === "generate") {
+    const [resource, subcommand] = positionalArgs(args);
+    if (resource !== "image") throw new Error(`Unknown generate command: ${resource}`);
+    if (subcommand === "plan") {
+      const prompt = readOption(args, "--prompt");
+      const rawCount = readOption(args, "--count");
+      const rawPerBaseCount = readOption(args, "--per-base-count");
+      if (!prompt) throw new Error("lineage generate image plan requires --prompt");
+      return planImageGeneration(options.project, {
+        count: rawCount === void 0 ? void 0 : Number(rawCount),
+        dryRun: args.includes("--dry-run"),
+        fromLineageSelection: args.includes("--from-lineage-selection"),
+        perBaseCount: rawPerBaseCount === void 0 ? void 0 : Number(rawPerBaseCount),
+        prompt
+      });
+    }
+    if (subcommand === "inspect") {
+      const jobId2 = readOption(args, "--job-id");
+      if (!jobId2) throw new Error("lineage generate image inspect requires --job-id");
+      return inspectImageGeneration(options.project, jobId2);
+    }
+    if (subcommand === "import") {
+      const jobId2 = readOption(args, "--job-id");
+      const manifestPath = readOption(args, "--manifest");
+      const filesValue = readOption(args, "--files");
+      const parentFilesValue = readOption(args, "--parent-files");
+      if (!jobId2) throw new Error("lineage generate image import requires --job-id");
+      if (manifestPath !== void 0 && (filesValue !== void 0 || parentFilesValue !== void 0)) {
+        throw new Error("Use --manifest or legacy --files/--parent-files, not both");
+      }
+      if (filesValue !== void 0 && parentFilesValue !== void 0) throw new Error("Use --files or --parent-files, not both");
+      return importImageGenerationOutputs(options.project, {
+        confirmWrite: options.confirmWrite,
+        files: filesValue === void 0 ? void 0 : filesValue.split(",").map((file) => file.trim()).filter(Boolean),
+        jobId: jobId2,
+        manifest: manifestPath === void 0 ? void 0 : readJsonFile(manifestPath, "Generation output manifest"),
+        parentFiles: parentFilesOption(parentFilesValue)
+      });
+    }
+    throw new Error(`Unknown generate image command: ${subcommand}`);
+  }
   if (command === "reroll") {
     const subcommand = positionalArgs(args)[0] || "";
     if (subcommand === "list") {
@@ -5640,6 +6448,15 @@ function printDataResult(command, result, json) {
     if (link.warning) console.log(`Warning: ${link.warning}`);
     return;
   }
+  if (command === "generate" && result && typeof result === "object" && "job" in result) {
+    const generation = result;
+    if (generation.imported) {
+      console.log(`${generation.idempotent ? "Already imported" : "Imported"} ${generation.imported.length} output(s) for ${generation.job?.id || "job"}`);
+    } else {
+      console.log(`Generation job ${generation.job?.id || "job"} ${generation.job?.status || "unknown"}`);
+    }
+    return;
+  }
   if (command === "reroll" && result && typeof result === "object") {
     if ("requests" in result) {
       const listed = result;
@@ -5715,6 +6532,18 @@ function runLineageProfileCommand(config, command, args) {
   const selector = profileSelector(args);
   if (!selector) throw new Error(`lineage profile ${command} requires --profile or LINEAGE_PROFILE`);
   if (command === "doctor") return doctorLineageProfile(selector, runtimeIdentity);
+  if (command === "repin-runtime") {
+    const checkoutRoot = readOption(args, "--checkout-root");
+    if (!checkoutRoot) throw new Error("Profile runtime repin requires --checkout-root");
+    if (!args.includes("--confirm-write")) throw new Error("Profile runtime repin requires --confirm-write");
+    const profile = resolveLineageProfile(selector);
+    const writerLease = acquireProfileWriterLease(profile, config.channel, "cli");
+    try {
+      return repinLineageDevelopmentProfileRuntime(selector, checkoutRoot, runtimeIdentity, true);
+    } finally {
+      writerLease.release();
+    }
+  }
   if (command === "bind") {
     if (!args.includes("--confirm-write")) throw new Error("Profile bind requires --confirm-write");
     const profile = resolveLineageProfile(selector);
@@ -5740,6 +6569,9 @@ function printProfileResult(result, json) {
   } else if (result.schema_version === "lineage.profile_clone_receipt.v1") {
     console.log(`Cloned ${result.source_database_path} to ${result.database_path} for ${result.target_identity.profile_id}`);
     console.log(`Receipt: ${result.receipt_path}`);
+  } else if (result.schema_version === "lineage.profile_runtime_repin_receipt.v1") {
+    console.log(`${result.changed ? "Repinned" : "Already pinned"} ${result.profile_id} to checkout ${result.checkout_root}`);
+    console.log(`Code fingerprint: ${result.new_code_fingerprint}`);
   } else {
     console.log(`Cloned ${result.files_copied} referenced asset file(s) into ${result.asset_root}`);
     console.log(`Receipt: ${result.receipt_path}`);
@@ -5770,7 +6602,9 @@ function printRuntimeResult(result, json) {
 }
 function lineageCliRequiresWriterLease(command, args) {
   if (command === "next" || command === "brief" || command === "inspect" || command === "selection") return false;
-  const subcommand = positionalArgs(args)[0] || "";
+  const positions = positionalArgs(args);
+  const subcommand = positions[0] || "";
+  if (command === "generate") return positions[0] !== "image" || positions[1] !== "inspect";
   if (command === "reroll") return subcommand !== "list";
   if (command === "tasks") return subcommand !== "list" && subcommand !== "inspect";
   if (command === "db") return subcommand !== "info";
@@ -6110,7 +6944,7 @@ async function runLineageCli(config, args = process.argv.slice(2)) {
     else console.error(`${config.binName}: ${message2}`);
     process.exit(1);
   }
-  if (command === "next" || command === "brief" || command === "inspect" || command === "selection" || command === "link-child" || command === "reroll" || command === "tasks") {
+  if (command === "next" || command === "brief" || command === "inspect" || command === "selection" || command === "link-child" || command === "generate" || command === "reroll" || command === "tasks") {
     const commandArgs = normalizedArgs.slice(1);
     const json2 = commandArgs.includes("--json");
     try {