ima2-gen 1.1.21 → 1.1.22

package/lib/storageMigration.ts

@@ -1,310 +0,0 @@
-import { mkdir, readdir, copyFile, stat, constants } from "node:fs/promises";
-import { dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { homedir } from "node:os";
-
-const PACKAGE_NAME = "ima2-gen";
-const RECOVERY_DOCS_PATH = "docs/RECOVER_OLD_IMAGES.md";
-
-interface CopyStats { copied: number; skippedExisting: number; }
-
-function addStats(a: CopyStats, b: CopyStats): CopyStats {
-  return {
-    copied: a.copied + b.copied,
-    skippedExisting: a.skippedExisting + b.skippedExisting,
-  };
-}
-
-async function copyMissingTree(srcDir: string, dstDir: string): Promise<CopyStats> {
-  await mkdir(dstDir, { recursive: true });
-  const entries = await readdir(srcDir, { withFileTypes: true });
-  let stats: CopyStats = { copied: 0, skippedExisting: 0 };
-  for (const entry of entries) {
-    const src = join(srcDir, entry.name);
-    const dst = join(dstDir, entry.name);
-    if (entry.isDirectory()) {
-      stats = addStats(stats, await copyMissingTree(src, dst));
-      continue;
-    }
-    if (!entry.isFile()) continue;
-    try {
-      await copyFile(src, dst, constants.COPYFILE_EXCL);
-      stats.copied += 1;
-    } catch (err) {
-      if ((err as { code?: string })?.code !== "EEXIST") throw err;
-      stats.skippedExisting += 1;
-    }
-  }
-  return stats;
-}
-
-function isSameOrInside(child: string, parent: string): boolean {
-  const a = resolve(child);
-  const b = resolve(parent);
-  return a === b || a.startsWith(b + sep);
-}
-
-interface StorageCtx {
-  rootDir?: string;
-  config?: { storage?: { generatedDir?: string } };
-}
-
-function resolveTargetDir(ctx: StorageCtx): string {
-  return ctx.config?.storage?.generatedDir ?? join(ctx.rootDir ?? process.cwd(), "generated");
-}
-
-type EnvLike = NodeJS.ProcessEnv;
-
-interface MigrateOptions {
-  legacyDirs?: string[];
-  env?: EnvLike;
-}
-
-export async function migrateGeneratedStorage(ctx: StorageCtx, options: MigrateOptions = {}) {
-  const targetDir = resolveTargetDir(ctx);
-  const candidates = options.legacyDirs || await getLegacyGeneratedCandidates(ctx, options.env);
-  const result = {
-    copied: 0,
-    skippedExisting: 0,
-    sourcesScanned: 0,
-    sourcesSkipped: 0,
-  };
-  try {
-    for (const legacyDir of candidates) {
-      if (isSameOrInside(legacyDir, targetDir) || isSameOrInside(targetDir, legacyDir)) {
-        result.sourcesSkipped += 1;
-        continue;
-      }
-      try {
-        const legacyStat = await stat(legacyDir);
-        if (!legacyStat.isDirectory()) continue;
-        result.sourcesScanned += 1;
-        const copyStats = await copyMissingTree(legacyDir, targetDir);
-        result.copied += copyStats.copied;
-        result.skippedExisting += copyStats.skippedExisting;
-      } catch (err) {
-        const e = err as { code?: string; message?: string };
-        if (e?.code !== "ENOENT") {
-          console.warn("[storage] generated asset migration source skipped:", legacyDir, e.message);
-        }
-      }
-    }
-    if (result.copied > 0) console.log(`[storage] migrated ${result.copied} generated assets to ${targetDir}`);
-  } catch (err) {
-    console.warn("[storage] generated asset migration skipped:", (err as { message?: string })?.message);
-  }
-  return result;
-}
-
-export async function getLegacyGeneratedCandidates(ctx: StorageCtx, env: EnvLike = process.env): Promise<string[]> {
-  const home = env.IMA2_TEST_HOME || homedir();
-  const execPath = env.IMA2_TEST_EXEC_PATH || process.execPath;
-  const argv1 = env.IMA2_TEST_ARGV1 || process.argv[1] || "";
-  const nodePrefix = dirname(dirname(execPath));
-  const prefixes = getGlobalPrefixCandidates({ env, execPath, argv1 });
-  const appData = env.APPDATA || join(home, "AppData", "Roaming");
-  const localAppData = env.LOCALAPPDATA || join(home, "AppData", "Local");
-  const npmCache = env.npm_config_cache || join(home, ".npm");
-  const xdgDataHome = env.XDG_DATA_HOME || join(home, ".local", "share");
-  const pnpmHome = env.PNPM_HOME || "";
-  const nvmHome = env.NVM_HOME || join(appData, "nvm");
-
-  const candidates = [
-    join(ctx.rootDir ?? process.cwd(), "generated"),
-    join(appData, "npm", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".npm-global", "lib", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".volta", "tools", "image", "packages", PACKAGE_NAME, "lib", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".bun", "install", "global", "node_modules", PACKAGE_NAME, "generated"),
-    join(home, ".config", "yarn", "global", "node_modules", PACKAGE_NAME, "generated"),
-    join(localAppData, "Yarn", "Data", "global", "node_modules", PACKAGE_NAME, "generated"),
-    join(localAppData, "Volta", "tools", "image", "packages", PACKAGE_NAME, "lib", "node_modules", PACKAGE_NAME, "generated"),
-    join(nvmHome, process.version, "node_modules", PACKAGE_NAME, "generated"),
-    join(dirname(execPath), "node_modules", PACKAGE_NAME, "generated"),
-  ];
-
-  for (const prefix of prefixes) {
-    candidates.push(join(prefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
-    candidates.push(join(prefix, "node_modules", PACKAGE_NAME, "generated"));
-  }
-
-  candidates.push(join(nodePrefix, "lib", "node_modules", PACKAGE_NAME, "generated"));
-  candidates.push(
-    ...await expandOneLevelCandidates([
-      [join(home, ".nvm", "versions", "node"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(home, ".fnm", "node-versions"), ["*", "installation", "lib", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(home, ".asdf", "installs", "nodejs"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(home, ".local", "share", "mise", "installs", "node"), ["*", "lib", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(home, "Library", "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(xdgDataHome, "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(localAppData, "pnpm", "global"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [pnpmHome ? join(pnpmHome, "global") : "", ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(npmCache, "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(localAppData, "npm-cache", "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [join(appData, "npm-cache", "_npx"), ["*", "node_modules", PACKAGE_NAME, "generated"]],
-      [nvmHome, ["*", "node_modules", PACKAGE_NAME, "generated"]],
-    ]),
-  );
-  return uniqueResolvedCandidates(candidates);
-}
-
-export async function inspectGeneratedStorage(ctx: StorageCtx, options: MigrateOptions = {}) {
-  const env = options.env || process.env;
-  const targetDir = resolveTargetDir(ctx);
-  try {
-    const candidates = options.legacyDirs || await getLegacyGeneratedCandidates(ctx, env);
-    const targetFileCount = await countFiles(targetDir);
-    const legacySources: Array<{ path: string; fileCount: number }> = [];
-
-    for (const candidate of candidates) {
-      if (isSameOrInside(candidate, targetDir) || isSameOrInside(targetDir, candidate)) continue;
-      try {
-        const candidateStat = await stat(candidate);
-        if (!candidateStat.isDirectory()) continue;
-        const fileCount = await countFiles(candidate);
-        if (fileCount > 0) legacySources.push({ path: candidate, fileCount });
-      } catch (err) {
-        const e = err as { code?: string; message?: string };
-        if (e?.code !== "ENOENT") {
-          console.warn("[storage] legacy candidate inspect skipped:", candidate, e.message);
-        }
-      }
-    }
-
-    const legacyFilesFound = legacySources.reduce((sum, source) => sum + source.fileCount, 0);
-    const state =
-      targetFileCount > 0 ? "ok"
-      : legacyFilesFound > 0 ? "recoverable"
-      : "not_found";
-
-    return {
-      ok: true,
-      targetDir,
-      generatedDirLabel: labelPath(targetDir, env),
-      targetExists: await isDirectory(targetDir),
-      targetFileCount,
-      legacyCandidatesScanned: candidates.length,
-      legacySourcesFound: legacySources.length,
-      legacyFilesFound,
-      legacySources,
-      overrides: {
-        generatedDir: Boolean(env.IMA2_GENERATED_DIR),
-        configDir: Boolean(env.IMA2_CONFIG_DIR),
-      },
-      state,
-      messageKind: state === "not_found" ? "apology" : state,
-      recoveryDocsPath: RECOVERY_DOCS_PATH,
-      doctorCommand: "ima2 doctor",
-    };
-  } catch (err) {
-    const e = err as { message?: string };
-    return {
-      ok: false,
-      targetDir,
-      generatedDirLabel: labelPath(targetDir, env),
-      targetExists: false,
-      targetFileCount: 0,
-      legacyCandidatesScanned: 0,
-      legacySourcesFound: 0,
-      legacyFilesFound: 0,
-      legacySources: [],
-      overrides: {
-        generatedDir: Boolean(env.IMA2_GENERATED_DIR),
-        configDir: Boolean(env.IMA2_CONFIG_DIR),
-      },
-      state: "unknown",
-      messageKind: "unknown",
-      recoveryDocsPath: RECOVERY_DOCS_PATH,
-      doctorCommand: "ima2 doctor",
-      error: e?.message || String(err),
-    };
-  }
-}
-
-type ExpandPattern = [string, string[]];
-
-async function expandOneLevelCandidates(patterns: ExpandPattern[]): Promise<string[]> {
-  const candidates: string[] = [];
-  for (const [baseDir, segments] of patterns) {
-    if (!baseDir) continue;
-    candidates.push(...await expandOneLevelPattern(baseDir, segments));
-  }
-  return candidates;
-}
-
-async function expandOneLevelPattern(baseDir: string, segments: string[]): Promise<string[]> {
-  const wildcardIndex = segments.indexOf("*");
-  if (wildcardIndex < 0) return [join(baseDir, ...segments)];
-
-  const before = segments.slice(0, wildcardIndex);
-  const after = segments.slice(wildcardIndex + 1);
-  const wildcardBase = join(baseDir, ...before);
-  try {
-    const entries = await readdir(wildcardBase, { withFileTypes: true });
-    return entries
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => join(wildcardBase, entry.name, ...after));
-  } catch (err) {
-    const e = err as { code?: string; message?: string };
-    if (e?.code === "ENOENT") return [];
-    console.warn("[storage] legacy candidate scan skipped:", wildcardBase, e.message);
-    return [];
-  }
-}
-
-async function countFiles(dir: string): Promise<number> {
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    let count = 0;
-    for (const entry of entries) {
-      if (entry.name === ".trash") continue;
-      const fullPath = join(dir, entry.name);
-      if (entry.isDirectory()) count += await countFiles(fullPath);
-      else if (entry.isFile()) count += 1;
-    }
-    return count;
-  } catch (err) {
-    if ((err as { code?: string })?.code === "ENOENT") return 0;
-    throw err;
-  }
-}
-
-async function isDirectory(dir: string): Promise<boolean> {
-  try {
-    return (await stat(dir)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-function uniqueResolvedCandidates(candidates: string[]): string[] {
-  return Array.from(new Set(candidates.filter(Boolean).map((p) => resolve(p))));
-}
-
-function labelPath(targetPath: string, env: EnvLike = process.env): string {
-  const home = env.IMA2_TEST_HOME || homedir();
-  const resolved = resolve(targetPath);
-  const resolvedHome = resolve(home);
-  if (resolved === resolvedHome) return "~";
-  if (resolved.startsWith(resolvedHome + sep)) return `~${sep}${resolved.slice(resolvedHome.length + 1)}`;
-  return resolved;
-}
-
-interface PrefixOpts { env: EnvLike; execPath: string; argv1: string; }
-
-function getGlobalPrefixCandidates({ env, execPath, argv1 }: PrefixOpts): string[] {
-  const prefixes: Set<string> = new Set();
-  if (env.npm_config_prefix) prefixes.add(env.npm_config_prefix);
-  if (isAbsolute(argv1)) prefixes.add(dirname(dirname(argv1)));
-  prefixes.add(dirname(dirname(execPath)));
-  addHomebrewPrefix(prefixes, execPath);
-  prefixes.add("/opt/homebrew");
-  prefixes.add("/usr/local");
-  return Array.from(prefixes);
-}
-
-function addHomebrewPrefix(prefixes: Set<string>, execPath: string): void {
-  const marker = `${sep}Cellar${sep}node`;
-  const idx = execPath.indexOf(marker);
-  if (idx > 0) prefixes.add(execPath.slice(0, idx));
-}

package/lib/styleSheet.ts

@@ -1,139 +0,0 @@
-// Style-sheet extractor (0.10)
-//
-// Uses GPT-5.4 (chat completions) to derive a structured "style guide" from a
-// user prompt and optional reference image. The style guide is stored per
-// session and automatically prepended to subsequent image generations so
-// continuations feel cohesive — closer to ChatGPT 4o's image carry-over.
-//
-// Shape:
-//   {
-//     palette: string[],         // e.g. ["deep navy", "gold leaf"]
-//     composition: string,       // e.g. "centered 3/4 portrait, shallow depth"
-//     mood: string,              // e.g. "melancholic, reverent"
-//     medium: string,            // e.g. "oil painting, glazed layers"
-//     subject_details: string,   // identity/pose/outfit cues for character continuity
-//     negative: string[]         // things to avoid
-//   }
-//
-// The module is pure JS + openai SDK. When no API key is configured it throws
-// STYLE_SHEET_NO_KEY so callers can surface a friendly "connect key" UI.
-
-import type OpenAI from "openai";
-import { config } from "../config.js";
-const STYLE_SHEET_MODEL = config.styleSheet.model;
-
-const SYSTEM_PROMPT = `You extract a reusable visual style guide from a user
-image prompt (and an optional reference image). Return ONLY a JSON object with
-these keys: palette (array of 3-6 concrete color names), composition (one
-sentence), mood (2-4 comma-separated adjectives), medium (one short phrase
-naming technique/material), subject_details (one sentence capturing identity
-cues: face, outfit, pose, distinctive features), negative (array of 0-4 short
-phrases of things to avoid). Keep entries tight — each under 120 characters.
-Do not wrap in markdown. Do not add commentary.`;
-
-interface StyleSheet {
-  palette: string[];
-  composition: string;
-  mood: string;
-  medium: string;
-  subject_details: string;
-  negative: string[];
-}
-
-function coerceStyleSheet(raw: unknown): StyleSheet | null {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-  const arr = (v: unknown, max = 6) =>
-    Array.isArray(v)
-      ? v
-          .filter((x: unknown) => typeof x === "string" && x.trim())
-          .slice(0, max)
-          .map((s: string) => s.trim())
-      : [];
-  const str = (v: unknown) => (typeof v === "string" ? v.trim().slice(0, 400) : "");
-  const r = raw as Record<string, unknown>;
-  const sheet: StyleSheet = {
-    palette: arr(r.palette, 6),
-    composition: str(r.composition),
-    mood: str(r.mood),
-    medium: str(r.medium),
-    subject_details: str(r.subject_details),
-    negative: arr(r.negative, 4),
-  };
-  const hasContent =
-    sheet.palette.length > 0 ||
-    sheet.negative.length > 0 ||
-    sheet.composition ||
-    sheet.mood ||
-    sheet.medium ||
-    sheet.subject_details;
-  return hasContent ? sheet : null;
-}
-
-export async function extractStyleSheet(openai: OpenAI | null | undefined, { prompt, referenceDataUrl }: { prompt: string; referenceDataUrl?: string }) {
-  if (!openai) {
-    const err = new Error("No OpenAI client configured for style-sheet extraction") as Error & { code?: string };
-    err.code = "STYLE_SHEET_NO_KEY";
-    throw err;
-  }
-  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
-    const err = new Error("prompt is required") as Error & { code?: string };
-    err.code = "STYLE_SHEET_BAD_INPUT";
-    throw err;
-  }
-
-  const userContent = referenceDataUrl
-    ? [
-        { type: "text" as const, text: prompt },
-        { type: "image_url" as const, image_url: { url: referenceDataUrl } },
-      ]
-    : prompt;
-
-  const resp = await openai.chat.completions.create({
-    model: STYLE_SHEET_MODEL,
-    response_format: { type: "json_object" },
-    messages: [
-      { role: "system", content: SYSTEM_PROMPT },
-      { role: "user", content: userContent },
-    ],
-  });
-
-  const raw = resp.choices?.[0]?.message?.content;
-  if (!raw) {
-    const err = new Error("Empty response from style-sheet model") as Error & { code?: string };
-    err.code = "STYLE_SHEET_EMPTY";
-    throw err;
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    const err = new Error("Style-sheet model returned non-JSON") as Error & { code?: string };
-    err.code = "STYLE_SHEET_PARSE";
-    throw err;
-  }
-
-  const sheet = coerceStyleSheet(parsed);
-  if (!sheet) {
-    const err = new Error("Style-sheet shape invalid") as Error & { code?: string };
-    err.code = "STYLE_SHEET_SHAPE";
-    throw err;
-  }
-  return sheet;
-}
-
-// Render a style sheet into a prompt preamble that gpt-image-1/2 can consume.
-// Kept short so it doesn't blow the 4K prompt window on long user prompts.
-export function renderStyleSheetPrefix(sheet: StyleSheet | null | undefined) {
-  if (!sheet) return "";
-  const parts: string[] = [];
-  if (sheet.medium) parts.push(`Medium: ${sheet.medium}.`);
-  if (sheet.palette?.length) parts.push(`Palette: ${sheet.palette.join(", ")}.`);
-  if (sheet.composition) parts.push(`Composition: ${sheet.composition}.`);
-  if (sheet.mood) parts.push(`Mood: ${sheet.mood}.`);
-  if (sheet.subject_details) parts.push(`Subject: ${sheet.subject_details}.`);
-  if (sheet.negative?.length) parts.push(`Avoid: ${sheet.negative.join(", ")}.`);
-  return parts.join(" ");
-}
-
-export { STYLE_SHEET_MODEL, SYSTEM_PROMPT, coerceStyleSheet };

package/lib/systemTrash.ts

@@ -1,20 +0,0 @@
-import { mkdir, rename } from "fs/promises";
-import { basename, join } from "path";
-import trash from "trash";
-
-export async function moveToSystemTrash(paths: string[]): Promise<void> {
-  if (process.env.NODE_ENV === "test" && process.env.IMA2_TEST_SYSTEM_TRASH_DIR) {
-    if (process.env.IMA2_TEST_SYSTEM_TRASH_FAIL === "1") {
-      throw new Error("Simulated system trash failure");
-    }
-    const targetDir = process.env.IMA2_TEST_SYSTEM_TRASH_DIR;
-    await mkdir(targetDir, { recursive: true });
-    const prefix = `${Date.now()}_`;
-    for (const path of paths) {
-      await rename(path, join(targetDir, `${prefix}${basename(path)}`));
-    }
-    return;
-  }
-
-  await trash(paths, { glob: false });
-}

package/lib/videoContinuity.ts

@@ -1,180 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { basename, join } from "node:path";
-
-export const ACTIVE_VIDEO_PROMPT_GUIDANCE = [
-  "Active video prompt required.",
-  "Describe visual flow, motion flow, sound or no-music intent, dialogue or no-dialogue intent, and the desired ending frame.",
-  "Pace the scene to naturally fill the selected duration, expanding even short requests into an opening composition, connected motion/emotion change, and stable ending frame.",
-  "Example: From the attached last frame, the subject turns toward camera, rain sound rises, no background music, one whispered line finishes before a still close-up ending.",
-].join(" ");
-
-export type VideoContinuityEntry = {
-  id: string;
-  ordinal: number;
-  role: "start" | "ancestor" | "parent" | "current";
-  filename: string | null;
-  userPrompt: string | null;
-  revisedPrompt: string;
-  createdAt: number;
-};
-
-export type VideoContinuityLineage = {
-  lineageId: string;
-  parentFilename: string | null;
-  sourceFrame: "last" | null;
-  maxEntries: 4;
-  retention: "keep-start-plus-latest-3";
-  entries: VideoContinuityEntry[];
-};
-
-type VideoMeta = {
-  prompt?: unknown;
-  userPrompt?: unknown;
-  revisedPrompt?: unknown;
-  createdAt?: unknown;
-  videoContinuity?: unknown;
-};
-
-export function requireActiveVideoPrompt(value: unknown): string | null {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-
-export function safeGeneratedVideoFilename(value: unknown): string {
-  if (typeof value !== "string" || !value.trim()) throw Object.assign(new Error("video filename required"), { status: 400 });
-  const clean = value.replace(/^\/generated\//, "").replace(/^\/+/, "");
-  if (clean.includes("..") || clean.includes("/") || clean.includes("\\")) {
-    throw Object.assign(new Error("invalid video filename"), { status: 400 });
-  }
-  if (!/\.mp4$/i.test(clean)) throw Object.assign(new Error("generated video input must be an .mp4 file"), { status: 400 });
-  return clean;
-}
-
-export async function readVideoSidecar(generatedDir: string, filename: string): Promise<VideoMeta | null> {
-  const safe = safeGeneratedVideoFilename(filename);
-  try {
-    return JSON.parse(await readFile(join(generatedDir, `${safe}.json`), "utf-8")) as VideoMeta;
-  } catch {
-    return null;
-  }
-}
-
-function stringOrNull(value: unknown): string | null {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-
-function numberOrNow(value: unknown): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : Date.now();
-}
-
-function entryFromMeta(filename: string, meta: VideoMeta | null): VideoContinuityEntry | null {
-  const revisedPrompt = stringOrNull(meta?.revisedPrompt) ?? stringOrNull(meta?.prompt);
-  if (!revisedPrompt) return null;
-  return {
-    id: `clip:${filename}`,
-    ordinal: 1,
-    role: "start",
-    filename,
-    userPrompt: stringOrNull(meta?.userPrompt) ?? stringOrNull(meta?.prompt),
-    revisedPrompt,
-    createdAt: numberOrNow(meta?.createdAt),
-  };
-}
-
-export function normalizeVideoContinuityLineage(value: unknown): VideoContinuityLineage | null {
-  if (!value || typeof value !== "object") return null;
-  const raw = value as Partial<VideoContinuityLineage>;
-  if (!Array.isArray(raw.entries)) return null;
-  const entries = raw.entries
-    .map((entry, index): VideoContinuityEntry | null => {
-      if (!entry || typeof entry !== "object") return null;
-      const e = entry as Partial<VideoContinuityEntry>;
-      const revisedPrompt = stringOrNull(e.revisedPrompt);
-      if (!revisedPrompt) return null;
-      return {
-        id: stringOrNull(e.id) ?? `entry:${index + 1}`,
-        ordinal: index + 1,
-        role: index === 0 ? "start" : index === raw.entries!.length - 1 ? "parent" : "ancestor",
-        filename: stringOrNull(e.filename),
-        userPrompt: stringOrNull(e.userPrompt),
-        revisedPrompt,
-        createdAt: numberOrNow(e.createdAt),
-      };
-    })
-    .filter((entry): entry is VideoContinuityEntry => Boolean(entry));
-  if (entries.length === 0) return null;
-  return {
-    lineageId: stringOrNull(raw.lineageId) ?? `lineage:${entries[0].id}`,
-    parentFilename: stringOrNull(raw.parentFilename),
-    sourceFrame: "last",
-    maxEntries: 4,
-    retention: "keep-start-plus-latest-3",
-    entries: trimLineageEntries(entries),
-  };
-}
-
-export function trimLineageEntries(entries: VideoContinuityEntry[]): VideoContinuityEntry[] {
-  const kept = entries.length <= 4 ? entries : [entries[0], ...entries.slice(-3)];
-  return kept.map((entry, index) => ({
-    ...entry,
-    ordinal: index + 1,
-    role: index === 0 ? "start" : index === kept.length - 1 ? entry.role : "ancestor",
-  }));
-}
-
-export function lineageFromVideoMetadata(filename: string, meta: VideoMeta | null): VideoContinuityLineage | null {
-  const existing = normalizeVideoContinuityLineage(meta?.videoContinuity);
-  if (existing) {
-    return { ...existing, parentFilename: filename, sourceFrame: "last" };
-  }
-  const entry = entryFromMeta(filename, meta);
-  if (!entry) return null;
-  return {
-    lineageId: `lineage:${filename.replace(/\.[^.]+$/, "")}`,
-    parentFilename: filename,
-    sourceFrame: "last",
-    maxEntries: 4,
-    retention: "keep-start-plus-latest-3",
-    entries: [entry],
-  };
-}
-
-export function appendVideoContinuityEntry(
-  parent: VideoContinuityLineage | null,
-  current: { filename: string; userPrompt: string | null; revisedPrompt: string; createdAt?: number },
-): VideoContinuityLineage {
-  const parentEntries = parent?.entries ?? [];
-  const lineageId = parent?.lineageId ?? `lineage:${current.filename.replace(/\.[^.]+$/, "")}`;
-  const currentEntry: VideoContinuityEntry = {
-    id: `clip:${current.filename}`,
-    ordinal: parentEntries.length + 1,
-    role: "current",
-    filename: current.filename,
-    userPrompt: current.userPrompt,
-    revisedPrompt: current.revisedPrompt,
-    createdAt: current.createdAt ?? Date.now(),
-  };
-  const entries = trimLineageEntries([...parentEntries.map((entry) => ({ ...entry, role: entry.role === "current" ? "parent" as const : entry.role })), currentEntry]);
-  return {
-    lineageId,
-    parentFilename: parent?.parentFilename ?? null,
-    sourceFrame: parent ? "last" : null,
-    maxEntries: 4,
-    retention: "keep-start-plus-latest-3",
-    entries,
-  };
-}
-
-export function formatVideoContinuityForPlanner(lineage: VideoContinuityLineage | null | undefined): string {
-  if (!lineage?.entries?.length) return "";
-  const lines = [
-    "[Continuity lineage: branch-local, max 4 entries, start anchor preserved]",
-    ...lineage.entries.map((entry) => [
-      `${entry.ordinal}. Clip ${entry.ordinal} / ${entry.role}`,
-      `   file: ${entry.filename ? basename(entry.filename) : "unknown"}`,
-      `   revisedPrompt: ${entry.revisedPrompt}`,
-      entry.userPrompt ? `   userPrompt: ${entry.userPrompt}` : null,
-    ].filter(Boolean).join("\n")),
-    "Continue from the final frame and final action/audio state of the latest lineage item. Do not restart the scene.",
-  ];
-  return lines.join("\n");
-}