@topogram/cli 0.3.75 → 0.3.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@topogram/cli",
-  "version": "0.3.75",
+  "version": "0.3.76",
   "description": "Topogram CLI for checking Topogram workspaces and generating app bundles.",
   "license": "Apache-2.0",
   "repository": {

package/src/adoption/plan/index.js

@@ -637,6 +637,7 @@ function mappingSuggestionsForItem(item) {
 }
 
 export function buildAgentAdoptionPlan(adoptionPlan, maintainedBoundaryArtifact = null) {
+  const importedMaintainedDbSeams = [...(adoptionPlan?.imported_maintained_db_seams || [])];
   const items = (adoptionPlan?.items || []).map((item) => {
     const currentState = inferCurrentAdoptionState(item);
     const maintainedSeamCandidates = inferMaintainedSeamCandidates({
@@ -656,6 +657,9 @@ export function buildAgentAdoptionPlan(adoptionPlan, maintainedBoundaryArtifact
       ui_impacts: [...(item.ui_impacts || [])],
       workflow_impacts: [...(item.workflow_impacts || [])]
     }, maintainedBoundaryArtifact);
+    const importedDbSeamCandidates = ["entity", "enum", "index", "relation", "db"].includes(item.kind) || item.track === "db"
+      ? importedMaintainedDbSeams
+      : [];
     return {
       id: adoptionItemKey(item),
       bundle: item.bundle,
@@ -691,11 +695,57 @@ export function buildAgentAdoptionPlan(adoptionPlan, maintainedBoundaryArtifact
       projection_impacts: [...(item.projection_impacts || [])],
       ui_impacts: [...(item.ui_impacts || [])],
       workflow_impacts: [...(item.workflow_impacts || [])],
-      maintained_seam_candidates: maintainedSeamCandidates,
+      maintained_seam_candidates: [...maintainedSeamCandidates, ...importedDbSeamCandidates],
       mapping_suggestions: mappingSuggestionsForItem(item),
       available_actions: ADOPTION_STATE_VOCABULARY
     };
   });
+  const importedDbSeamSurfaces = importedMaintainedDbSeams.map((seam) => ({
+    id: seam.id_hint || seam.seam_id,
+    bundle: "database",
+    item: seam.id_hint || seam.seam_id,
+    kind: seam.kind || "maintained_db_migration_seam",
+    track: "db",
+    source_kind: seam.source_kind || "migration_strategy_inference",
+    source_path: "candidates/app/db/candidates.json",
+    canonical_rel_path: null,
+    related_shapes: [],
+    review_boundary: {
+      automation_class: "review_required",
+      reasons: [
+        "manual_project_config_review",
+        "proposal_only_maintained_db_migration_seam"
+      ]
+    },
+    current_state: "stage",
+    recommended_state: "customize",
+    supported_states: ADOPTION_STATE_VOCABULARY,
+    human_review_required: true,
+    provenance: {
+      bundle: "database",
+      source_path: "candidates/app/db/candidates.json",
+      canonical_rel_path: null
+    },
+    requirements: {
+      related_docs: [],
+      related_capabilities: [],
+      related_shapes: [],
+      related_rules: [],
+      related_workflows: [],
+      blocking_dependencies: []
+    },
+    projection_impacts: [],
+    ui_impacts: [],
+    workflow_impacts: [],
+    maintained_seam_candidates: [seam],
+    mapping_suggestions: [{
+      type: "manual_project_config_review",
+      id: seam.id_hint || seam.seam_id,
+      reason: "Review the inferred database migration strategy before editing topogram.project.json."
+    }],
+    available_actions: ADOPTION_STATE_VOCABULARY
+  }));
+  const proposalSurfaces = [...items, ...importedDbSeamSurfaces];
 
   return {
     type: "agent_adoption_plan",
@@ -708,10 +758,11 @@ export function buildAgentAdoptionPlan(adoptionPlan, maintainedBoundaryArtifact
       non_canonical_adoption_state: "stage"
     },
     approved_review_groups: [...new Set(adoptionPlan?.approved_review_groups || [])].sort(),
-    imported_proposal_surfaces: items,
-    staged_items: items.filter((item) => item.current_state === "stage").map((item) => item.id),
-    accepted_items: items.filter((item) => item.current_state === "accept").map((item) => item.id),
-    rejected_items: items.filter((item) => item.current_state === "reject").map((item) => item.id),
-    requires_human_review: items.filter((item) => item.human_review_required).map((item) => item.id)
+    imported_maintained_db_seam_candidates: importedMaintainedDbSeams,
+    imported_proposal_surfaces: proposalSurfaces,
+    staged_items: proposalSurfaces.filter((item) => item.current_state === "stage").map((item) => item.id),
+    accepted_items: proposalSurfaces.filter((item) => item.current_state === "accept").map((item) => item.id),
+    rejected_items: proposalSurfaces.filter((item) => item.current_state === "reject").map((item) => item.id),
+    requires_human_review: proposalSurfaces.filter((item) => item.human_review_required).map((item) => item.id)
   };
 }

package/src/cli/commands/import/workspace.js

@@ -110,6 +110,7 @@ export function importCandidateCounts(summary) {
   return {
     dbEntities: candidates.db?.entities?.length || 0,
     dbEnums: candidates.db?.enums?.length || 0,
+    dbMaintainedSeams: candidates.db?.maintained_seams?.length || 0,
     apiCapabilities: candidates.api?.capabilities?.length || 0,
     apiRoutes: candidates.api?.routes?.length || 0,
     uiScreens: candidates.ui?.screens?.length || 0,

package/src/import/core/runner/candidates.js

@@ -261,7 +261,8 @@ export function normalizeCandidatesForTrack(track, candidates) {
       entities: dedupeCandidateRecords(candidates.entities || [], idHint),
       enums: dedupeCandidateRecords(candidates.enums || [], idHint),
       relations: dedupeCandidateRecords(candidates.relations || [], idHint),
-      indexes: dedupeCandidateRecords(candidates.indexes || [], idHint)
+      indexes: dedupeCandidateRecords(candidates.indexes || [], idHint),
+      maintained_seams: dedupeCandidateRecords(candidates.maintained_seams || [], idHint)
     };
   }
   if (track === "api") {

package/src/import/core/runner/reports.js

@@ -10,8 +10,11 @@ import { uiWidgetCandidates } from "./candidates.js";
  */
 export function reportMarkdown(track, candidates) {
   if (track === "db") {
+    const seamLines = (candidates.maintained_seams || []).map((/** @type {any} */ seam) =>
+      `- \`${seam.id_hint}\` tool \`${seam.tool}\` confidence ${seam.confidence || "unknown"} schema \`${seam.schemaPath || "none"}\` migrations \`${seam.migrationsPath || "review-required"}\` missing decisions ${(seam.missing_decisions || []).length}`
+    );
     return ensureTrailingNewline(
-      `# DB Import Report\n\n- Entities: ${candidates.entities.length}\n- Enums: ${candidates.enums.length}\n- Relations: ${candidates.relations.length}\n- Indexes: ${candidates.indexes.length}\n`
+      `# DB Import Report\n\n- Entities: ${candidates.entities.length}\n- Enums: ${candidates.enums.length}\n- Relations: ${candidates.relations.length}\n- Indexes: ${candidates.indexes.length}\n- Maintained DB migration seams: ${(candidates.maintained_seams || []).length}\n\n## Maintained DB Migration Seam Candidates\n\n${seamLines.length ? seamLines.join("\n") : "- none"}\n`
     );
   }
   if (track === "api") {
@@ -54,6 +57,6 @@ export function reportMarkdown(track, candidates) {
  */
 export function appReportMarkdown(candidates, tracks) {
   return ensureTrailingNewline(
-    `# App Import Report\n\nTracks: ${tracks.join(", ")}\n\n## DB\n\n- Entities: ${candidates.db?.entities?.length || 0}\n- Enums: ${candidates.db?.enums?.length || 0}\n- Relations: ${candidates.db?.relations?.length || 0}\n\n## API\n\n- Capabilities: ${candidates.api?.capabilities?.length || 0}\n- Routes: ${candidates.api?.routes?.length || 0}\n- Stacks: ${candidates.api?.stacks?.length ? candidates.api.stacks.join(", ") : "none"}\n\n## UI\n\n- Screens: ${candidates.ui?.screens?.length || 0}\n- Routes: ${candidates.ui?.routes?.length || 0}\n- Actions: ${candidates.ui?.actions?.length || 0}\n- Widgets: ${uiWidgetCandidates(candidates.ui).length}\n- Event payload shapes: ${candidates.ui?.shapes?.length || 0}\n- Stacks: ${candidates.ui?.stacks?.length ? candidates.ui.stacks.join(", ") : "none"}\n\n## CLI\n\n- Commands: ${candidates.cli?.commands?.length || 0}\n- Capabilities: ${candidates.cli?.capabilities?.length || 0}\n- CLI surfaces: ${candidates.cli?.surfaces?.length || 0}\n\n## Workflows\n\n- Workflows: ${candidates.workflows?.workflows?.length || 0}\n- States: ${candidates.workflows?.workflow_states?.length || 0}\n- Transitions: ${candidates.workflows?.workflow_transitions?.length || 0}\n\n## Verification\n\n- Verifications: ${candidates.verification?.verifications?.length || 0}\n- Scenarios: ${candidates.verification?.scenarios?.length || 0}\n- Frameworks: ${candidates.verification?.frameworks?.length ? candidates.verification.frameworks.join(", ") : "none"}\n- Scripts: ${candidates.verification?.scripts?.length || 0}\n`
+    `# App Import Report\n\nTracks: ${tracks.join(", ")}\n\n## DB\n\n- Entities: ${candidates.db?.entities?.length || 0}\n- Enums: ${candidates.db?.enums?.length || 0}\n- Relations: ${candidates.db?.relations?.length || 0}\n- Maintained DB migration seams: ${candidates.db?.maintained_seams?.length || 0}\n\n## API\n\n- Capabilities: ${candidates.api?.capabilities?.length || 0}\n- Routes: ${candidates.api?.routes?.length || 0}\n- Stacks: ${candidates.api?.stacks?.length ? candidates.api.stacks.join(", ") : "none"}\n\n## UI\n\n- Screens: ${candidates.ui?.screens?.length || 0}\n- Routes: ${candidates.ui?.routes?.length || 0}\n- Actions: ${candidates.ui?.actions?.length || 0}\n- Widgets: ${uiWidgetCandidates(candidates.ui).length}\n- Event payload shapes: ${candidates.ui?.shapes?.length || 0}\n- Stacks: ${candidates.ui?.stacks?.length ? candidates.ui.stacks.join(", ") : "none"}\n\n## CLI\n\n- Commands: ${candidates.cli?.commands?.length || 0}\n- Capabilities: ${candidates.cli?.capabilities?.length || 0}\n- CLI surfaces: ${candidates.cli?.surfaces?.length || 0}\n\n## Workflows\n\n- Workflows: ${candidates.workflows?.workflows?.length || 0}\n- States: ${candidates.workflows?.workflow_states?.length || 0}\n- Transitions: ${candidates.workflows?.workflow_transitions?.length || 0}\n\n## Verification\n\n- Verifications: ${candidates.verification?.verifications?.length || 0}\n- Scenarios: ${candidates.verification?.scenarios?.length || 0}\n- Frameworks: ${candidates.verification?.frameworks?.length ? candidates.verification.frameworks.join(", ") : "none"}\n- Scripts: ${candidates.verification?.scripts?.length || 0}\n`
   );
 }

package/src/import/core/runner/tracks.js

@@ -96,7 +96,7 @@ function selectDetectionsForTrack(track, detections) {
  */
 function initialCandidatesForTrack(track) {
   if (track === "db") {
-    return { entities: [], enums: [], relations: [], indexes: [] };
+    return { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
   }
   if (track === "api") {
     return { capabilities: [], routes: [], stacks: [] };

package/src/import/extractors/db/drizzle.js

@@ -10,6 +10,7 @@ import {
   slugify,
   titleCase
 } from "../../core/shared.js";
+import { inferDrizzleMaintainedDbSeams } from "./maintained-seams.js";
 
 function splitTopLevelEntries(block) {
   const entries = [];
@@ -165,21 +166,50 @@ function parseDrizzleTables(schemaText) {
   };
 }
 
+function drizzleConfigFiles(context) {
+  return findImportFiles(context.paths, (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath)));
+}
+
+function configuredSchemaFiles(context, configFiles) {
+  const files = [];
+  for (const configFile of configFiles) {
+    const configText = context.helpers.readTextIfExists(configFile) || "";
+    for (const match of configText.matchAll(/\bschema\s*:\s*["'`]([^"'`*]+)["'`]/g)) {
+      const absoluteSchemaPath = path.resolve(path.dirname(configFile), match[1]);
+      if (context.helpers.readTextIfExists(absoluteSchemaPath) !== null) {
+        files.push(absoluteSchemaPath);
+      }
+    }
+  }
+  return files;
+}
+
+function findDrizzleSchemaFiles(context) {
+  const configFiles = drizzleConfigFiles(context);
+  const conventionalSchemaFiles = findImportFiles(context.paths, (filePath) =>
+    /(?:^|\/)(?:src\/db\/schema|src\/schema|db\/schema|schema)\.(ts|js|mjs|cjs)$/i.test(relativeTo(context.paths.workspaceRoot, filePath).replaceAll(path.sep, "/"))
+  );
+  return [...new Set([
+    ...configuredSchemaFiles(context, configFiles),
+    ...conventionalSchemaFiles
+  ])].sort();
+}
+
 export const drizzleExtractor = {
   id: "db.drizzle",
   track: "db",
   detect(context) {
-    const hasConfig = findImportFiles(context.paths, (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath))).length > 0;
-    const hasSchema = findImportFiles(context.paths, (filePath) => /src\/schema\.(ts|js|mjs|cjs)$/i.test(filePath)).length > 0;
+    const hasConfig = drizzleConfigFiles(context).length > 0;
+    const hasSchema = findDrizzleSchemaFiles(context).length > 0;
     return {
       score: hasConfig || hasSchema ? 95 : 0,
       reasons: hasConfig || hasSchema ? ["Found Drizzle config/schema source"] : []
     };
   },
   extract(context) {
-    const schemaFiles = findImportFiles(context.paths, (filePath) => /src\/schema\.(ts|js|mjs|cjs)$/i.test(filePath));
+    const schemaFiles = findDrizzleSchemaFiles(context);
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of schemaFiles) {
       const parsed = parseDrizzleTables(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -237,6 +267,7 @@ export const drizzleExtractor = {
     candidates.enums = dedupeCandidateRecords(candidates.enums, (record) => record.id_hint);
     candidates.relations = dedupeCandidateRecords(candidates.relations, (record) => record.id_hint);
     candidates.indexes = dedupeCandidateRecords(candidates.indexes, (record) => record.id_hint);
+    candidates.maintained_seams = inferDrizzleMaintainedDbSeams(context, schemaFiles);
     return { findings, candidates };
   }
 };

package/src/import/extractors/db/maintained-seams.js

@@ -0,0 +1,208 @@
+// @ts-check
+
+import path from "node:path";
+
+import { findImportFiles, makeCandidateRecord, relativeTo } from "../../core/shared.js";
+
+/** @param {string} value @returns {string} */
+function toPosix(value) {
+  return String(value || "").replaceAll(path.sep, "/");
+}
+
+/** @param {any} context @param {string} filePath @returns {string} */
+function appRelativePath(context, filePath) {
+  return toPosix(relativeTo(context.paths.workspaceRoot, filePath));
+}
+
+/** @param {any} context @param {string} filePath @returns {string} */
+function evidencePath(context, filePath) {
+  return toPosix(relativeTo(context.paths.repoRoot, filePath));
+}
+
+/** @param {string} relativePath @param {string[]} segments @returns {string|null} */
+function prefixThroughSegments(relativePath, segments) {
+  const parts = toPosix(relativePath).split("/");
+  for (let index = 0; index <= parts.length - segments.length; index += 1) {
+    if (segments.every((segment, offset) => parts[index + offset] === segment)) {
+      return parts.slice(0, index + segments.length).join("/");
+    }
+  }
+  return null;
+}
+
+/** @param {string} relativePath @returns {string|null} */
+function migrationDirectoryFromRelativePath(relativePath) {
+  return prefixThroughSegments(relativePath, ["migrations"]) ||
+    prefixThroughSegments(relativePath, ["migration"]);
+}
+
+/** @param {any} context @param {string[]} files @param {string[][]} markers @returns {string|null} */
+function firstMarkedDirectory(context, files, markers) {
+  const directories = new Set();
+  for (const filePath of files) {
+    const relativePath = appRelativePath(context, filePath);
+    for (const marker of markers) {
+      const directory = prefixThroughSegments(relativePath, marker);
+      if (directory) {
+        directories.add(directory);
+      }
+    }
+  }
+  return [...directories].sort()[0] || null;
+}
+
+/** @param {any} context @param {string[]} configFiles @returns {string|null} */
+function drizzleOutPathFromConfig(context, configFiles) {
+  for (const configFile of configFiles.sort()) {
+    const configText = context.helpers.readTextIfExists(configFile) || "";
+    const outMatch = configText.match(/\bout\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (!outMatch) {
+      continue;
+    }
+    const absoluteOut = path.resolve(path.dirname(configFile), outMatch[1]);
+    const relativeOut = appRelativePath(context, absoluteOut);
+    if (relativeOut && !relativeOut.startsWith("..")) {
+      return relativeOut;
+    }
+  }
+  return null;
+}
+
+/**
+ * @param {any} context
+ * @param {{ tool: "sql"|"prisma"|"drizzle", schemaPath?: string|null, migrationsPath?: string|null, evidence: string[], matchReasons: string[], missingDecisions: string[] }} options
+ * @returns {any}
+ */
+function maintainedDbSeamCandidate(context, options) {
+  const runtimeId = "app_db";
+  const projectionId = "proj_db";
+  const snapshotPath = `topo/state/db/${runtimeId}/current.snapshot.json`;
+  const proposedRuntimeMigration = {
+    ownership: "maintained",
+    tool: options.tool,
+    apply: "never",
+    snapshotPath,
+    ...(options.schemaPath ? { schemaPath: options.schemaPath } : {}),
+    ...(options.migrationsPath ? { migrationsPath: options.migrationsPath } : {})
+  };
+  const idHint = `seam_${options.tool}_db_migrations`;
+
+  return makeCandidateRecord({
+    kind: "maintained_db_migration_seam",
+    idHint,
+    label: `${options.tool.toUpperCase()} maintained database migrations`,
+    confidence: options.missingDecisions.length === 0 ? "high" : "medium",
+    sourceKind: "migration_strategy_inference",
+    sourceOfTruth: "candidate",
+    provenance: options.evidence,
+    track: "db",
+    seam_id: idHint,
+    output_id: "maintained_app",
+    ownership_class: "human_owned",
+    status: "review_required",
+    tool: options.tool,
+    ownership: "maintained",
+    apply: "never",
+    schemaPath: options.schemaPath || null,
+    migrationsPath: options.migrationsPath || null,
+    snapshotPath,
+    runtime_id_hint: runtimeId,
+    projection_id_hint: projectionId,
+    evidence: options.evidence,
+    match_reasons: options.matchReasons,
+    missing_decisions: options.missingDecisions,
+    proposed_runtime_migration: proposedRuntimeMigration,
+    maintained_modules: [options.schemaPath, options.migrationsPath].filter(Boolean),
+    emitted_dependencies: [snapshotPath, projectionId],
+    allowed_change_classes: ["proposal_only"],
+    drift_signals: ["schema_or_migration_changed", "migration_directory_changed"]
+  });
+}
+
+/** @param {any} context @param {string[]} prismaFiles @returns {any[]} */
+export function inferPrismaMaintainedDbSeams(context, prismaFiles) {
+  if (!prismaFiles.length) {
+    return [];
+  }
+  const schemaPath = appRelativePath(context, prismaFiles[0]);
+  const migrationFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => toPosix(filePath).includes("/prisma/migrations/")));
+  const migrationsPath = firstMarkedDirectory(context, migrationFiles, [["prisma", "migrations"]]);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "prisma",
+      schemaPath,
+      migrationsPath,
+      evidence: [
+        ...prismaFiles.map((filePath) => evidencePath(context, filePath)),
+        ...migrationFiles.slice(0, 3).map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        "found Prisma schema",
+        ...(migrationsPath ? ["found Prisma migrations directory"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm Prisma migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}
+
+/** @param {any} context @param {string[]} schemaFiles @returns {any[]} */
+export function inferDrizzleMaintainedDbSeams(context, schemaFiles) {
+  if (!schemaFiles.length) {
+    return [];
+  }
+  const configFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => /drizzle\.config\.(ts|js|mjs|cjs)$/i.test(path.basename(filePath))));
+  const drizzleFiles = /** @type {string[]} */ (findImportFiles(context.paths, /** @param {string} filePath */ (filePath) => appRelativePath(context, filePath).startsWith("drizzle/")));
+  const configuredOutPath = drizzleOutPathFromConfig(context, configFiles);
+  const migrationsPath = configuredOutPath ||
+    firstMarkedDirectory(context, drizzleFiles, [["drizzle"]]);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "drizzle",
+      schemaPath: appRelativePath(context, schemaFiles[0]),
+      migrationsPath,
+      evidence: [
+        ...schemaFiles.map((filePath) => evidencePath(context, filePath)),
+        ...configFiles.map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath)),
+        ...drizzleFiles.slice(0, 3).map(/** @param {string} filePath */ (filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        "found Drizzle schema source",
+        ...(configFiles.length ? ["found Drizzle config"] : []),
+        ...(migrationsPath ? ["found Drizzle migrations output"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm Drizzle migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}
+
+/** @param {any} context @param {string[]} allSqlFiles @param {string[]} selectedSqlFiles @returns {any[]} */
+export function inferSqlMaintainedDbSeams(context, allSqlFiles, selectedSqlFiles) {
+  if (!allSqlFiles.length) {
+    return [];
+  }
+  const schemaFile = selectedSqlFiles.find((filePath) => !/migration/i.test(path.basename(filePath))) ||
+    allSqlFiles.find((filePath) => /schema/i.test(path.basename(filePath))) ||
+    null;
+  const migrationFiles = allSqlFiles.filter((filePath) => {
+    const relativePath = appRelativePath(context, filePath);
+    return Boolean(migrationDirectoryFromRelativePath(relativePath)) || /migration/i.test(path.basename(filePath));
+  });
+  const migrationsPath = firstMarkedDirectory(context, migrationFiles, [["migrations"], ["migration"]]) ||
+    (migrationFiles.length ? toPosix(path.dirname(appRelativePath(context, migrationFiles[0]))) : null);
+  return [
+    maintainedDbSeamCandidate(context, {
+      tool: "sql",
+      schemaPath: schemaFile ? appRelativePath(context, schemaFile) : null,
+      migrationsPath,
+      evidence: [
+        ...(schemaFile ? [evidencePath(context, schemaFile)] : []),
+        ...migrationFiles.slice(0, 3).map((filePath) => evidencePath(context, filePath))
+      ],
+      matchReasons: [
+        ...(schemaFile ? ["found SQL schema"] : []),
+        ...(migrationsPath ? ["found SQL migrations directory or migration file"] : [])
+      ],
+      missingDecisions: migrationsPath ? [] : ["confirm SQL migrationsPath before adding this strategy to topogram.project.json"]
+    })
+  ];
+}

package/src/import/extractors/db/prisma.js

@@ -8,6 +8,7 @@ import {
   titleCase,
   idHintify
 } from "../../core/shared.js";
+import { inferPrismaMaintainedDbSeams } from "./maintained-seams.js";
 
 function parsePrismaSchema(schemaText) {
   const enums = [];
@@ -125,7 +126,7 @@ export const prismaExtractor = {
       "prisma"
     );
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of prismaFiles) {
       const parsed = parsePrismaSchema(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -179,7 +180,7 @@ export const prismaExtractor = {
         track: "db"
       })));
     }
+    candidates.maintained_seams = inferPrismaMaintainedDbSeams(context, prismaFiles);
     return { findings, candidates };
   }
 };
-

package/src/import/extractors/db/sql.js

@@ -1,4 +1,5 @@
 import { canonicalCandidateTerm, findImportFiles, makeCandidateRecord, relativeTo, selectPreferredImportFiles, slugify, titleCase, idHintify } from "../../core/shared.js";
+import { inferSqlMaintainedDbSeams } from "./maintained-seams.js";
 
 function parseTableConstraint(line, tableName) {
   const normalized = line.replace(/,$/, "").trim();
@@ -119,7 +120,7 @@ export const sqlExtractor = {
         ? selectPreferredImportFiles(context.paths, schemaSqlFiles, "sql")
         : selectPreferredImportFiles(context.paths, migrationSqlFiles, "sql");
     const findings = [];
-    const candidates = { entities: [], enums: [], relations: [], indexes: [] };
+    const candidates = { entities: [], enums: [], relations: [], indexes: [], maintained_seams: [] };
     for (const filePath of sqlFiles) {
       const parsed = parseSqlSchema(context.helpers.readTextIfExists(filePath) || "");
       const provenance = relativeTo(context.paths.repoRoot, filePath);
@@ -175,6 +176,7 @@ export const sqlExtractor = {
         track: "db"
       })));
     }
+    candidates.maintained_seams = inferSqlMaintainedDbSeams(context, allSqlFiles, sqlFiles);
     return { findings, candidates };
   }
 };

package/src/workflows/reconcile/candidate-model.js

@@ -81,7 +81,7 @@ export function bestContextBundleForCandidate(bundles, candidate) {
 
 /** @param {ResolvedGraph} graph @param {ImportArtifacts} appImport @param {any} topogramRoot @returns {any} */
 export function buildCandidateModelBundles(graph, appImport, topogramRoot) {
-  const dbCandidates = appImport.candidates.db || { entities: [], enums: [] };
+  const dbCandidates = appImport.candidates.db || { entities: [], enums: [], maintained_seams: [] };
   const apiCandidates = appImport.candidates.api || { capabilities: [] };
   const uiCandidates = appImport.candidates.ui || { screens: [], routes: [], actions: [], widgets: [], shapes: [] };
   const uiWidgetCandidates = uiCandidates.widgets || uiCandidates.components || [];
@@ -151,6 +151,10 @@ export function buildCandidateModelBundles(graph, appImport, topogramRoot) {
       bundles.delete(`enum_${enumId}`);
     }
   }
+  for (const seam of dbCandidates.maintained_seams || []) {
+    const bundle = getOrCreateCandidateBundle(bundles, "database", "Database");
+    bundle.maintainedSeams = [...(bundle.maintainedSeams || []), seam];
+  }
   for (const entry of apiCandidates.capabilities || []) {
     const matchedCapability = graph ? matchImportedApiCapability(entry, topogramApiCapabilities) : null;
     if (matchedCapability) {
@@ -333,7 +337,8 @@ export function buildCandidateModelBundles(graph, appImport, topogramRoot) {
       bundle.workflows.length > 0 ||
       bundle.verifications.length > 0 ||
       bundle.workflowStates.length > 0 ||
-      bundle.workflowTransitions.length > 0
+      bundle.workflowTransitions.length > 0 ||
+      (bundle.maintainedSeams || []).length > 0
     )
     .map((/** @type {any} */ bundle) => {
       const sortedBundle = {
@@ -353,6 +358,7 @@ export function buildCandidateModelBundles(graph, appImport, topogramRoot) {
         verifications: bundle.verifications.sort((/** @type {any} */ a, /** @type {any} */ b) => a.id_hint.localeCompare(b.id_hint)),
         workflowStates: bundle.workflowStates.sort((/** @type {any} */ a, /** @type {any} */ b) => a.id_hint.localeCompare(b.id_hint)),
         workflowTransitions: bundle.workflowTransitions.sort((/** @type {any} */ a, /** @type {any} */ b) => a.id_hint.localeCompare(b.id_hint)),
+        maintainedSeams: (bundle.maintainedSeams || []).sort((/** @type {any} */ a, /** @type {any} */ b) => a.id_hint.localeCompare(b.id_hint)),
         docs: bundle.docs.sort((/** @type {any} */ a, /** @type {any} */ b) => a.id.localeCompare(b.id))
       };
       const mergeHints = buildBundleMergeHints(sortedBundle, canonicalEntityIds);

package/src/workflows/reconcile/workflow.js

@@ -91,6 +91,7 @@ export function reconcileWorkflow(inputPath, options = {}) {
     type: "reconcile_adoption_plan",
     workspace: paths.topogramRoot,
     approved_review_groups: [...new Set(existingPlan?.approved_review_groups || [])],
+    imported_maintained_db_seams: appImport.candidates?.db?.maintained_seams || [],
     items: mergedPlanItems,
     projection_review_groups: buildProjectionReviewGroups(mergedPlanItems),
     ui_review_groups: buildUiReviewGroups(mergedPlanItems),