@hiai-gg/docsmint 0.6.0 → 0.6.2

package/dist/backend/index.js

@@ -42744,6 +42744,7 @@ __export(exports_schema, {
   documentRelations: () => documentRelations,
   documentPipelineRuns: () => documentPipelineRuns,
   documentPipelineBatches: () => documentPipelineBatches,
+  documentKnowledgeSummaries: () => documentKnowledgeSummaries,
   documentEmbeddings: () => documentEmbeddings,
   documentEmbeddingRelations: () => documentEmbeddingRelations,
   documentCreateOperations: () => documentCreateOperations,
@@ -42756,7 +42757,7 @@ __export(exports_schema, {
   apiKeyRelations: () => apiKeyRelations,
   accounts: () => accounts
 });
-var vector4, tsvector, documentVisibilityEnum, shareRoleEnum, shareAccessModeEnum, shareGrantStatusEnum, embeddingStatusEnum, pipelineStageEnum, pipelineStatusEnum, lifecycleOperationKindEnum, lifecycleOperationStatusEnum, users, sessions, accounts, verifications, folders, folderRelations, documents, documentRelations, documentPipelineRuns, documentPipelineBatches, tags, tagRelations, categories, categoryRelations, documentTags, documentTagRelations, shareLinks, shareLinkRelations, guestAccess, guestAccessRelations, attachments, attachmentRelations, versions, documentEmbeddings, documentEmbeddingRelations, apiKeys, apiKeyRelations, auditLog, lifecycleOperations, documentCreateOperations, versionRelations;
+var vector4, tsvector, documentVisibilityEnum, shareRoleEnum, shareAccessModeEnum, shareGrantStatusEnum, embeddingStatusEnum, pipelineStageEnum, pipelineStatusEnum, lifecycleOperationKindEnum, lifecycleOperationStatusEnum, users, sessions, accounts, verifications, folders, folderRelations, documents, documentRelations, documentPipelineRuns, documentPipelineBatches, documentKnowledgeSummaries, tags, tagRelations, categories, categoryRelations, documentTags, documentTagRelations, shareLinks, shareLinkRelations, guestAccess, guestAccessRelations, attachments, attachmentRelations, versions, documentEmbeddings, documentEmbeddingRelations, apiKeys, apiKeyRelations, auditLog, lifecycleOperations, documentCreateOperations, versionRelations;
 var init_schema2 = __esm(() => {
   init_pg_core();
   init_drizzle_orm();
@@ -43010,6 +43011,22 @@ var init_schema2 = __esm(() => {
     index("document_pipeline_batches_stage_status_available_idx").on(table3.stage, table3.status, table3.availableAt),
     index("document_pipeline_batches_document_id_idx").on(table3.documentId)
   ]);
+  documentKnowledgeSummaries = pgTable("document_knowledge_summaries", {
+    id: uuid().primaryKey().defaultRandom(),
+    document_id: uuid().notNull().references(() => documents.id, { onDelete: "cascade" }),
+    owner_id: uuid().notNull().references(() => users.id, { onDelete: "cascade" }),
+    workspace_id: text(),
+    generation_id: uuid().notNull(),
+    revision: text().notNull(),
+    language: text().notNull(),
+    description: text().notNull(),
+    keywords: text().array().notNull().default(sql`ARRAY[]::text[]`),
+    created_at: timestamp().defaultNow().notNull(),
+    updated_at: timestamp().defaultNow().notNull()
+  }, (table3) => [
+    uniqueIndex("document_knowledge_summaries_document_generation_idx").on(table3.document_id, table3.generation_id),
+    index("document_knowledge_summaries_owner_document_idx").on(table3.owner_id, table3.document_id)
+  ]);
   tags = pgTable("tags", {
     id: uuid("id").primaryKey().defaultRandom(),
     ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
@@ -173203,6 +173220,8 @@ async function validateApiKey(key) {
     scopes
   };
 }
+// ../db/src/document-writer.ts
+init_schema2();
 
 // ../db/src/index.ts
 init_schema2();
@@ -194094,6 +194113,7 @@ function contentAccessForExternalContext(ctx) {
     permissions.add("write");
   } else if (ctx.actorRole === "editor") {
     permissions.add("edit");
+    permissions.add("write");
   }
   return {
     principal: { kind: "session", userId: ctx.userId },
@@ -194144,6 +194164,9 @@ function canAccessContent(access, action) {
     return access.permissions.has(action);
   return !access.restricted || access.permissions.has(action);
 }
+function canManageCategories(access) {
+  return !access.restricted && canAccessContent(access, "write");
+}
 function effectiveDocumentCategory(row) {
   return row.categoryId ?? row.folderCategoryId ?? null;
 }
@@ -194237,7 +194260,8 @@ var enqueueDocumentPipelineSchema = exports_external2.object({
   workspaceId: exports_external2.string().min(1).optional(),
   revision: exports_external2.string().min(1),
   source: pipelineSourceSchema,
-  requestedAt: exports_external2.iso.datetime().optional()
+  requestedAt: exports_external2.iso.datetime().optional(),
+  forceNewGeneration: exports_external2.boolean().optional()
 });
 var JOB_IDS = {
   prepare: (documentId, generationId, workspaceId) => `prepare-${documentId}-${generationId}${workspaceId ? `-${workspaceId}` : ""}`,
@@ -194266,7 +194290,14 @@ var postgresRunStore = {
       const [document2] = await tx.select({ id: documents.id }).from(documents).where(and(eq(documents.id, input.documentId), ownerBoundary)).limit(1);
       if (!document2)
         throw new Error("Document not found for pipeline owner");
-      const [existing] = await tx.select({ generationId: documentPipelineRuns.generationId }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.documentId, input.documentId), runBoundary, eq(documentPipelineRuns.revision, input.revision), inArray(documentPipelineRuns.status, [...ACTIVE_STATUSES]))).limit(1);
+      if (input.forceNewGeneration) {
+        await tx.update(documentPipelineRuns).set({
+          status: "cancelled",
+          errorCode: "superseded_by_reindex",
+          updatedAt: new Date
+        }).where(and(eq(documentPipelineRuns.documentId, input.documentId), runBoundary, inArray(documentPipelineRuns.status, [...ACTIVE_STATUSES])));
+      }
+      const [existing] = input.forceNewGeneration ? [] : await tx.select({ generationId: documentPipelineRuns.generationId }).from(documentPipelineRuns).where(and(eq(documentPipelineRuns.documentId, input.documentId), runBoundary, eq(documentPipelineRuns.revision, input.revision), inArray(documentPipelineRuns.status, [...ACTIVE_STATUSES]))).limit(1);
       if (existing)
         return { run: existing, created: false };
       const [created] = await tx.insert(documentPipelineRuns).values({
@@ -194302,7 +194333,8 @@ async function enqueueDocumentPipeline(input, dependencies) {
   const { run, created } = await deps.runs.findOrCreate({
     ...parsed,
     requestedAt,
-    generationId: proposedGenerationId
+    generationId: proposedGenerationId,
+    forceNewGeneration: parsed.forceNewGeneration
   });
   if (created) {
     const job2 = {
@@ -194373,10 +194405,10 @@ ${content52}`;
 init_logger3();
 init_redis();
 var LEGACY_EMBEDDING_QUEUE_KEY = "hiai-docs:embedding-queue";
-async function enqueueEmbedding(documentId, source = "interactive") {
+async function enqueueEmbedding(documentId, source = "interactive", workspaceId, options = {}) {
   let pipelineInput;
   try {
-    await withTenant(adminTenantContext(ZERO_UUID), async (tx) => {
+    await withTenant({ ...adminTenantContext(ZERO_UUID), workspaceId }, async (tx) => {
       const rows = await tx.select({
         active: documents.activeEmbeddingGeneration,
         ownerId: documents.ownerId,
@@ -194387,7 +194419,7 @@ async function enqueueEmbedding(documentId, source = "interactive") {
       if (!document2)
         return;
       const revision = contentHash(document2.title, document2.content ?? "");
-      pipelineInput = { ownerId: document2.ownerId, revision };
+      pipelineInput = { ownerId: document2.ownerId, revision, workspaceId };
       const activeGeneration = document2.active;
       if (activeGeneration) {
         await tx.update(documents).set({
@@ -194410,8 +194442,10 @@ async function enqueueEmbedding(documentId, source = "interactive") {
     await enqueueDocumentPipeline({
       documentId,
       ownerId: pipelineInput.ownerId,
+      workspaceId: pipelineInput.workspaceId,
       revision: pipelineInput.revision,
-      source
+      source,
+      forceNewGeneration: options.forceNewGeneration
     });
     return true;
   } catch (err) {
@@ -194449,7 +194483,7 @@ async function enqueueReembed(docIds, workspaceId) {
   let pushed = 0;
   for (const id2 of unique) {
     if (await claimEnqueueSlot(id2, workspaceId)) {
-      enqueueEmbedding(id2);
+      enqueueEmbedding(id2, "interactive", workspaceId);
       pushed += 1;
     }
   }
@@ -196359,9 +196393,6 @@ init_schema2();
 init_drizzle_orm();
 init_zod();
 init_logger3();
-function isCategoryManager(principal) {
-  return principal?.kind === "session" || principal?.kind === "operator";
-}
 var createCategorySchema = exports_external2.object({
   name: exports_external2.string().trim().min(1).max(255),
   apiMode: exports_external2.enum(["unavailable", "global", "category"]).optional(),
@@ -196499,9 +196530,9 @@ var categoryRoutes = new Elysia({ prefix: "/api" }).get("/categories", async ({
     set2.status = 401;
     return { error: "Unauthorized" };
   }
-  if (!isCategoryManager(access.principal)) {
+  if (!canManageCategories(access)) {
     set2.status = 403;
-    return { error: "Browser session or operator credential required" };
+    return { error: "Full workspace write access required" };
   }
   const userId = ctx.userId;
   const parsed = createCategorySchema.safeParse(await request.json());
@@ -196551,9 +196582,9 @@ var categoryRoutes = new Elysia({ prefix: "/api" }).get("/categories", async ({
     set2.status = 401;
     return { error: "Unauthorized" };
   }
-  if (!isCategoryManager(access.principal)) {
+  if (!canManageCategories(access)) {
     set2.status = 403;
-    return { error: "Browser session or operator credential required" };
+    return { error: "Full workspace write access required" };
   }
   const userId = ctx.userId;
   const parsed = updateCategorySchema.safeParse(await request.json());
@@ -196622,9 +196653,9 @@ var categoryRoutes = new Elysia({ prefix: "/api" }).get("/categories", async ({
     set2.status = 401;
     return { error: "Unauthorized" };
   }
-  if (!isCategoryManager(access.principal)) {
+  if (!canManageCategories(access)) {
     set2.status = 403;
-    return { error: "Browser session or operator credential required" };
+    return { error: "Full workspace write access required" };
   }
   const userId = ctx.userId;
   try {
@@ -227123,6 +227154,7 @@ var cursorListQuerySchema = exports_external2.object({
   sortBy: exports_external2.enum(["title", "category", "folder", "updated"]).default("updated"),
   sortOrder: exports_external2.enum(["asc", "desc"]).default("desc")
 });
+var documentIdParamsSchema = exports_external2.object({ id: exports_external2.string().uuid() });
 function cursorScopeHash(input) {
   return Buffer.from(new Bun.CryptoHasher("sha256").update(input).digest("hex"), "utf8").toString("base64url");
 }
@@ -227641,6 +227673,180 @@ var documentRoutes = new Elysia({ prefix: "/api" }).get("/documents", async ({ q
     set2.status = 500;
     return { error: "Failed to load pipeline progress" };
   }
+}).get("/documents/:id/knowledge-summary", async ({ params: params2, set: set2, request }) => {
+  const parsedParams = documentIdParamsSchema.safeParse(params2);
+  if (!parsedParams.success) {
+    set2.status = 400;
+    return { error: "Invalid document id" };
+  }
+  const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? "unknown";
+  const rl = await documentRateLimiter(ip, request);
+  if (!rl.allowed) {
+    set2.status = 429;
+    set2.headers = rateLimitHeaders(0, rl.retryAfter);
+    return { error: "Too many requests" };
+  }
+  set2.headers = rateLimitHeaders(rl.remaining);
+  const access = await resolveContentAccess(request);
+  const ctx = access.ctx;
+  if (ctx.role === "none") {
+    set2.status = 401;
+    return { error: "Unauthorized" };
+  }
+  if (!canAccessContent(access, "read")) {
+    set2.status = 403;
+    return { error: "Forbidden" };
+  }
+  const [summary] = await withTenant(ctx, (tx) => tx.select({
+    documentId: documentKnowledgeSummaries.document_id,
+    generationId: documentKnowledgeSummaries.generation_id,
+    revision: documentKnowledgeSummaries.revision,
+    language: documentKnowledgeSummaries.language,
+    description: documentKnowledgeSummaries.description,
+    keywords: documentKnowledgeSummaries.keywords,
+    createdAt: documentKnowledgeSummaries.created_at,
+    updatedAt: documentKnowledgeSummaries.updated_at
+  }).from(documentKnowledgeSummaries).innerJoin(documents, eq(documents.id, documentKnowledgeSummaries.document_id)).where(and(eq(documentKnowledgeSummaries.document_id, parsedParams.data.id), eq(documentKnowledgeSummaries.generation_id, documents.activeEmbeddingGeneration), tenantOwnerCondition(documents.ownerId, documents.workspaceId, ctx), isNull(documents.deletedAt), ...access.restricted && access.categoryId ? [eq(documents.categoryId, access.categoryId)] : [])).limit(1));
+  if (!summary) {
+    set2.status = 404;
+    return { error: "Knowledge summary not found" };
+  }
+  return summary;
+}).get("/documents/:id/index-status", async ({ params: params2, set: set2, request }) => {
+  const parsedParams = documentIdParamsSchema.safeParse(params2);
+  if (!parsedParams.success) {
+    set2.status = 400;
+    return { error: "Invalid document id" };
+  }
+  const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? "unknown";
+  const rl = await documentRateLimiter(ip, request);
+  if (!rl.allowed) {
+    set2.status = 429;
+    set2.headers = rateLimitHeaders(0, rl.retryAfter);
+    return { error: "Too many requests" };
+  }
+  set2.headers = rateLimitHeaders(rl.remaining);
+  const access = await resolveContentAccess(request);
+  const ctx = access.ctx;
+  if (ctx.role === "none") {
+    set2.status = 401;
+    return { error: "Unauthorized" };
+  }
+  if (!canAccessContent(access, "read")) {
+    set2.status = 403;
+    return { error: "Forbidden" };
+  }
+  const result = await withTenant(ctx, async (tx) => {
+    const [document2] = await tx.select({
+      id: documents.id,
+      embeddingStatus: documents.embeddingStatus,
+      activeGenerationId: documents.activeEmbeddingGeneration,
+      pendingGenerationId: documents.pendingEmbeddingGeneration,
+      embeddingProfile: documents.embeddingProfile,
+      embeddingErrorCode: documents.embeddingErrorCode,
+      embeddingUpdatedAt: documents.embeddingUpdatedAt
+    }).from(documents).where(and(eq(documents.id, parsedParams.data.id), tenantOwnerCondition(documents.ownerId, documents.workspaceId, ctx), isNull(documents.deletedAt), ...access.restricted && access.categoryId ? [eq(documents.categoryId, access.categoryId)] : [])).limit(1);
+    if (!document2)
+      return null;
+    const active = document2.activeGenerationId ? await tx.select({ id: documentEmbeddings.id }).from(documentEmbeddings).where(and(eq(documentEmbeddings.documentId, document2.id), eq(documentEmbeddings.generationId, document2.activeGenerationId), eq(documentEmbeddings.isValid, true), eq(documentEmbeddings.embeddingDimensions, 1024), eq(documentEmbeddings.embeddingProfile, document2.embeddingProfile ?? ""))).limit(1) : [];
+    const [run5] = await tx.select({
+      documentId: documentPipelineRuns.documentId,
+      generationId: documentPipelineRuns.generationId,
+      revision: documentPipelineRuns.revision,
+      status: documentPipelineRuns.status,
+      prepareStatus: documentPipelineRuns.prepareStatus,
+      embedStatus: documentPipelineRuns.embedStatus,
+      graphStatus: documentPipelineRuns.graphStatus,
+      summarizeStatus: documentPipelineRuns.summarizeStatus,
+      finalizeStatus: documentPipelineRuns.finalizeStatus,
+      totalBatches: documentPipelineRuns.totalBatches,
+      completedBatches: documentPipelineRuns.completedBatches,
+      failedBatches: documentPipelineRuns.failedBatches,
+      updatedAt: documentPipelineRuns.updatedAt
+    }).from(documentPipelineRuns).where(eq(documentPipelineRuns.documentId, document2.id)).orderBy(desc(documentPipelineRuns.updatedAt)).limit(1);
+    return {
+      document: document2,
+      searchable: active.length > 0,
+      run: run5
+    };
+  });
+  if (!result) {
+    set2.status = 404;
+    return { error: "Document not found" };
+  }
+  const run4 = result.run;
+  return {
+    documentId: result.document.id,
+    embeddingStatus: result.document.embeddingStatus,
+    activeGenerationId: result.document.activeGenerationId,
+    pendingGenerationId: result.document.pendingGenerationId,
+    embeddingProfile: result.document.embeddingProfile,
+    embeddingErrorCode: result.document.embeddingErrorCode,
+    embeddingUpdatedAt: result.document.embeddingUpdatedAt,
+    searchable: result.searchable,
+    pipeline: run4 ? {
+      documentId: run4.documentId,
+      generationId: run4.generationId,
+      status: run4.status,
+      revision: run4.revision,
+      stages: {
+        prepare: run4.prepareStatus,
+        embed: run4.embedStatus,
+        graph: run4.graphStatus,
+        summarize: run4.summarizeStatus,
+        finalize: run4.finalizeStatus
+      },
+      batches: {
+        total: run4.totalBatches,
+        completed: run4.completedBatches,
+        failed: run4.failedBatches
+      },
+      updatedAt: run4.updatedAt
+    } : null
+  };
+}).post("/documents/:id/index/refresh", async ({ params: params2, set: set2, request }) => {
+  const parsedParams = documentIdParamsSchema.safeParse(params2);
+  if (!parsedParams.success) {
+    set2.status = 400;
+    return { error: "Invalid document id" };
+  }
+  const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? "unknown";
+  const rl = await writeRateLimiter(ip, request);
+  if (!rl.allowed) {
+    set2.status = 429;
+    set2.headers = rateLimitHeaders(0, rl.retryAfter);
+    return { error: "Too many requests" };
+  }
+  set2.headers = rateLimitHeaders(rl.remaining);
+  const access = await resolveContentAccess(request);
+  const ctx = access.ctx;
+  if (ctx.role === "none") {
+    set2.status = 401;
+    return { error: "Unauthorized" };
+  }
+  if (!canAccessContent(access, "edit")) {
+    set2.status = 403;
+    return { error: "Forbidden" };
+  }
+  const [document2] = await withTenant(ctx, (tx) => tx.select({
+    id: documents.id,
+    ownerId: documents.ownerId,
+    title: documents.title,
+    content: documents.content
+  }).from(documents).where(and(eq(documents.id, parsedParams.data.id), tenantOwnerCondition(documents.ownerId, documents.workspaceId, ctx), isNull(documents.deletedAt), ...access.restricted && access.categoryId ? [eq(documents.categoryId, access.categoryId)] : [])).limit(1));
+  if (!document2) {
+    set2.status = 404;
+    return { error: "Document not found" };
+  }
+  const queued = await enqueueDocumentPipeline({
+    documentId: document2.id,
+    ownerId: document2.ownerId,
+    workspaceId: ctx.workspaceId,
+    revision: contentHash(document2.title, document2.content ?? ""),
+    source: "api"
+  });
+  set2.status = 202;
+  return { documentId: document2.id, ...queued };
 }).get("/documents/:id", async ({ params: params2, set: set2, request }) => {
   const ip = request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ?? request.headers.get("x-real-ip") ?? "unknown";
   const rl = await documentRateLimiter(ip, request);
@@ -229073,14 +229279,15 @@ var graphRoutes = new Elysia({ prefix: "/api/graph" }).get("/entities", async ({
     set2.status = 400;
     return { error: "Invalid query", details: parsed.error.flatten() };
   }
-  if (!config3.GRAPH_SEARCH_ENABLED) {
-    return { entities: [] };
-  }
   try {
     const allowedIds = await allowedGraphDocumentIds(access, [
       parsed.data.docId
     ]);
-    if (!allowedIds.has(parsed.data.docId))
+    if (!allowedIds.has(parsed.data.docId)) {
+      set2.status = 404;
+      return { error: "Document not found" };
+    }
+    if (!config3.GRAPH_SEARCH_ENABLED)
       return { entities: [] };
     const entities = await fetchDocumentEntities(parsed.data.docId);
     return { entities };
@@ -229112,14 +229319,15 @@ var graphRoutes = new Elysia({ prefix: "/api/graph" }).get("/entities", async ({
     set2.status = 400;
     return { error: "Invalid params", details: parsed.error.flatten() };
   }
-  if (!config3.GRAPH_SEARCH_ENABLED) {
-    return { related: [] };
-  }
   try {
     const seedIds = await allowedGraphDocumentIds(access, [
       parsed.data.docId
     ]);
-    if (!seedIds.has(parsed.data.docId))
+    if (!seedIds.has(parsed.data.docId)) {
+      set2.status = 404;
+      return { error: "Document not found" };
+    }
+    if (!config3.GRAPH_SEARCH_ENABLED)
       return { related: [] };
     const related = await fetchRelatedDocuments(ctx, parsed.data.docId, access);
     return { related };
@@ -229152,12 +229360,16 @@ var graphRoutes = new Elysia({ prefix: "/api/graph" }).get("/entities", async ({
     return { error: "Invalid body", details: parsed.error.flatten() };
   }
   const { query, docIds, maxResults } = parsed.data;
-  if (!config3.GRAPH_SEARCH_ENABLED) {
-    return { query, entities: [], relatedDocs: [] };
-  }
   try {
     const authorizedSeeds = await allowedGraphDocumentIds(access, docIds);
-    const result = await graphRagLookup(ctx, docIds.filter((id3) => authorizedSeeds.has(id3)), maxResults, access);
+    if (docIds.some((id3) => !authorizedSeeds.has(id3))) {
+      set2.status = 404;
+      return { error: "One or more documents were not found" };
+    }
+    if (!config3.GRAPH_SEARCH_ENABLED) {
+      return { query, entities: [], relatedDocs: [] };
+    }
+    const result = await graphRagLookup(ctx, docIds, maxResults, access);
     return { query, ...result };
   } catch (err) {
     logger3.warn({ err, docIds: docIds.length }, "Graph RAG search failed \u2014 returning empty");
@@ -230229,7 +230441,6 @@ async function retrieveVector(ctx, plan, limit, minimum, chunkLimit, execute, pr
 			JOIN documents d ON d.id = de.document_id
 			WHERE d.owner_id = ${ctx.userId}
 				${scope}
-				AND d.embedding_status = 'ready'
 				AND d.active_embedding_generation IS NOT NULL
 				AND de.generation_id = d.active_embedding_generation
 				AND de.is_valid = true
@@ -230961,7 +231172,6 @@ async function hydrateResults(ctx, items, includeChunks, query, allowedDocumentI
 					JOIN documents d ON d.id = de.document_id
 					WHERE de.document_id IN (${sql.join(ids.map((id3) => sql`${id3}`), sql`, `)})
 						AND ${tenantOwnerSql("d", ctx)}
-						AND d.embedding_status = 'ready'
 						AND d.active_embedding_generation IS NOT NULL
 						AND de.generation_id = d.active_embedding_generation
 						AND de.is_valid = true
@@ -232729,6 +232939,116 @@ async function ensureApiKeyOwner() {
 init_config();
 init_logger3();
 
+// ../../backend/src/lib/reembed-cron.ts
+init_schema2();
+init_drizzle_orm();
+init_config();
+
+// ../../backend/src/lib/cron-timer-registry.ts
+function createCronTimerRegistry(clear = clearInterval) {
+  const handles = [];
+  let closed = false;
+  return {
+    register(handle) {
+      if (closed) {
+        clear(handle);
+        return;
+      }
+      handles.push(handle);
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      for (const handle of handles)
+        clear(handle);
+      handles.length = 0;
+    }
+  };
+}
+
+// ../../backend/src/lib/reembed-cron.ts
+init_logger3();
+var METADATA_DEBOUNCE_MINUTES = 3;
+var CRON_BATCH_SIZE = 100;
+var CRON_TENANT = adminTenantContext(ZERO_UUID);
+function startReembedCron() {
+  const timers = createCronTimerRegistry();
+  const metadataIntervalMs = config3.METADATA_REEMBED_CRON_INTERVAL_MINUTES * 60 * 1000;
+  if (metadataIntervalMs > 0) {
+    logger3.info({ intervalMinutes: config3.METADATA_REEMBED_CRON_INTERVAL_MINUTES }, "Reembed metadata-stale cron started");
+    processStaleMetadataChanges().catch((err) => {
+      logger3.error({ err }, "Reembed metadata-stale cron initial run failed");
+    });
+    timers.register(setInterval(() => {
+      processStaleMetadataChanges().catch((err) => {
+        logger3.error({ err }, "Reembed metadata-stale cron tick failed");
+      });
+    }, metadataIntervalMs));
+  } else {
+    logger3.warn("METADATA_REEMBED_CRON_INTERVAL_MINUTES=0 \u2014 metadata-stale cron is DISABLED. " + "Metadata-only changes will NOT trigger re-embed until the cron is re-enabled.");
+  }
+  const idleIntervalMs = config3.REEMBED_CRON_INTERVAL_MINUTES * 60 * 1000;
+  if (idleIntervalMs > 0) {
+    logger3.info({ intervalMinutes: config3.REEMBED_CRON_INTERVAL_MINUTES }, "Reembed idle-pending cron started");
+    processIdlePendingChanges().catch((err) => {
+      logger3.error({ err }, "Reembed idle-pending cron initial run failed");
+    });
+    timers.register(setInterval(() => {
+      processIdlePendingChanges().catch((err) => {
+        logger3.error({ err }, "Reembed idle-pending cron tick failed");
+      });
+    }, idleIntervalMs));
+  } else {
+    logger3.warn("REEMBED_CRON_INTERVAL_MINUTES=0 \u2014 idle-pending cron is DISABLED. " + "Sub-threshold edits will NOT trigger catch-up embeds until the cron is re-enabled.");
+  }
+  return { close: () => timers.close() };
+}
+async function processStaleMetadataChanges() {
+  const cutoff = new Date(Date.now() - METADATA_DEBOUNCE_MINUTES * 60 * 1000);
+  const stale = await withTenant(CRON_TENANT, (tx) => tx.select({
+    id: documents.id,
+    workspaceId: documents.workspaceId,
+    metadataChangedAt: documents.metadataChangedAt
+  }).from(documents).where(and(isNotNull(documents.metadataChangedAt), lt(documents.metadataChangedAt, cutoff))).orderBy(documents.metadataChangedAt).limit(CRON_BATCH_SIZE));
+  if (stale.length === 0)
+    return;
+  logger3.debug({ count: stale.length }, "Reembed cron: processing stale metadata changes");
+  let enqueued = 0;
+  for (const row of stale) {
+    const originalTimestamp = row.metadataChangedAt instanceof Date ? row.metadataChangedAt.toISOString() : String(row.metadataChangedAt);
+    const cleared = await withTenant(CRON_TENANT, (tx) => tx.execute(sql`
+				UPDATE documents
+				SET metadata_changed_at = NULL
+				WHERE id = ${row.id}
+				  AND metadata_changed_at = ${originalTimestamp}
+				RETURNING id
+			`));
+    if (Array.isArray(cleared) && cleared.length > 0) {
+      await enqueueReembed([row.id], row.workspaceId ?? undefined);
+      enqueued += 1;
+    }
+  }
+  if (enqueued > 0) {
+    logger3.info({ scanned: stale.length, enqueued }, "Reembed cron: enqueued stale metadata changes");
+  }
+}
+async function processIdlePendingChanges() {
+  const cutoff = new Date(Date.now() - config3.REEMBED_MAX_IDLE_HOURS * 3600000);
+  const idle = await withTenant(CRON_TENANT, (tx) => tx.select({ id: documents.id, workspaceId: documents.workspaceId }).from(documents).where(and(eq(documents.pendingMinorChanges, true), lt(documents.lastSignificantUpdateAt, cutoff))).orderBy(documents.lastSignificantUpdateAt).limit(CRON_BATCH_SIZE));
+  if (idle.length === 0)
+    return;
+  logger3.debug({ count: idle.length }, "Reembed cron: processing idle pending-minor changes");
+  let enqueued = 0;
+  for (const row of idle) {
+    await enqueueReembed([row.id], row.workspaceId ?? undefined);
+    enqueued += 1;
+  }
+  if (enqueued > 0) {
+    logger3.info({ scanned: idle.length, enqueued }, "Reembed cron: enqueued idle pending-minor changes");
+  }
+}
+
 // ../../backend/src/queue/adapters.ts
 init_schema2();
 init_drizzle_orm();
@@ -232782,15 +233102,62 @@ async function activateEmbeddingGeneration(documentId, generationId, expectedChu
 // ../../backend/src/queue/adapters.ts
 init_config();
 
+// ../../backend/src/lib/graph/generation-state.ts
+function literal2(value) {
+  return JSON.stringify(value);
+}
+function isStaleRevisionError(error53) {
+  return error53 instanceof Error && error53.name === "stale_revision";
+}
+async function runGenerationFencedGraphWrite(dependencies) {
+  if (!await dependencies.lockCurrentGeneration()) {
+    const error53 = new Error("graph generation is stale");
+    error53.name = "stale_revision";
+    throw error53;
+  }
+  await dependencies.persist();
+}
+function graphReplacementCyphers(identity) {
+  const documentId = literal2(identity.documentId);
+  const generationId = literal2(identity.generationId);
+  const revision = literal2(identity.revision);
+  const timestamp3 = literal2(identity.timestamp);
+  return [
+    `MATCH (d:Document {id: ${documentId}})-[legacy:MENTIONS]->()
+		 DELETE legacy RETURN count(legacy)`,
+    `MATCH ()-[r]->() WHERE r.document_id = ${documentId}
+		 DELETE r RETURN count(r)`,
+    `MERGE (d:Document {id: ${documentId}})
+		 SET d.generation_id = ${generationId}, d.revision = ${revision},
+		     d.created_at = coalesce(d.created_at, ${timestamp3}),
+		     d.entity_extracted_at = ${timestamp3}
+		 RETURN d.id`
+  ];
+}
+function graphCompensationCyphers(documentIdValue, generationIdValue) {
+  const documentId = literal2(documentIdValue);
+  const generationId = literal2(generationIdValue);
+  return [
+    `MATCH ()-[r]->()
+		 WHERE r.document_id = ${documentId}
+		   AND r.generation_id = ${generationId}
+		 DELETE r RETURN count(r)`,
+    `MATCH (d:Document {id: ${documentId}})
+		 WHERE d.generation_id = ${generationId}
+		 DETACH DELETE d RETURN count(d)`
+  ];
+}
+
 // ../../backend/src/lib/graph/delete-document-state.ts
-async function deleteDocumentGraphState(documentId) {
+async function deleteDocumentGraphGeneration(documentId, generationId) {
   const sql6 = await getGraphDb();
   if (!sql6)
     return;
-  const literal2 = JSON.stringify(documentId);
   await sql6.begin(async (tx) => {
     await tx.unsafe("SET LOCAL search_path = ag_catalog, public");
-    await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ MATCH (d:Document {id: ${literal2}}) DETACH DELETE d RETURN 1 $$) AS (deleted agtype)`);
+    for (const cypher of graphCompensationCyphers(documentId, generationId)) {
+      await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${cypher} $$) AS (deleted agtype)`);
+    }
   });
 }
 
@@ -232813,8 +233180,9 @@ var RELATION_TYPES = [
   "AUTHORED_BY"
 ];
 var EXTRACT_DEDUP_TTL_SECONDS = 24 * 60 * 60;
-function extractDedupKey(documentId, chunkIndex, chunkHash2) {
-  return `hiai-docs:extract:done:${documentId}:${chunkIndex}:${chunkHash2}`;
+function extractDedupKey(documentId, chunkIndex, chunkHash2, generationId) {
+  const generation = generationId ? `${generationId}:` : "";
+  return `hiai-docs:extract:done:${documentId}:${generation}${chunkIndex}:${chunkHash2}`;
 }
 var DEFAULT_MAX_TOKENS = 1024;
 var DEFAULT_TEMPERATURE = 0;
@@ -232835,12 +233203,24 @@ function setCachedEntity(name, type, confidence) {
 async function extractEntities(chunkText2, documentId, options = {}) {
   if (!config3.GRAPH_EXTRACT_ENABLED)
     return [];
+  let claimedDedupKey;
+  const releaseDedupClaim = async () => {
+    if (!claimedDedupKey)
+      return;
+    try {
+      await redis.del(claimedDedupKey);
+    } catch (err) {
+      logger3.warn({ err, documentId, claimedDedupKey }, "Failed to release extract-dedup slot");
+    }
+  };
   if (options.chunkHash && options.chunkIndex !== undefined) {
-    const key = extractDedupKey(documentId, options.chunkIndex, options.chunkHash);
+    const key = extractDedupKey(documentId, options.chunkIndex, options.chunkHash, options.generationId);
     let acquired = false;
     try {
       const result = await redis.set(key, "1", "EX", EXTRACT_DEDUP_TTL_SECONDS, "NX");
       acquired = result === "OK";
+      if (acquired)
+        claimedDedupKey = key;
     } catch (err) {
       logger3.warn({ err, documentId, chunkIndex: options.chunkIndex }, "Extract-dedup Redis SET failed \u2014 falling through to extraction");
       acquired = true;
@@ -232849,22 +233229,31 @@ async function extractEntities(chunkText2, documentId, options = {}) {
       return [];
   }
   const sql6 = await getGraphDb();
-  if (!sql6)
+  if (!sql6) {
+    await releaseDedupClaim();
     return [];
-  if (!chunkText2)
+  }
+  if (!chunkText2) {
+    await releaseDedupClaim();
     return [];
+  }
   let entities;
   try {
     entities = await callEntityExtractionLLM(chunkText2, options);
   } catch (err) {
+    await releaseDedupClaim();
     logger3.warn({ err, documentId }, "Entity extraction LLM call failed \u2014 skipping");
     return [];
   }
-  if (entities.length === 0)
-    return [];
   try {
-    await persistEntities(sql6, documentId, entities);
+    await persistEntities(sql6, documentId, entities, {
+      generationId: options.generationId ?? "legacy",
+      revision: options.revision ?? "legacy"
+    });
   } catch (err) {
+    await releaseDedupClaim();
+    if (isStaleRevisionError(err))
+      throw err;
     logger3.warn({ err, documentId, count: entities.length }, "Failed to persist extracted entities to AGE \u2014 discarding");
     return [];
   }
@@ -233033,30 +233422,55 @@ function stripMarkdownFences(text4) {
   const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(text4.trim());
   return fenced?.[1] ?? text4;
 }
-async function persistEntities(sql6, documentId, entities) {
+async function persistEntities(sql6, documentId, entities, identity) {
   await sql6.begin(async (tx) => {
     await tx`SELECT pg_catalog.set_config('search_path', 'ag_catalog, "$user", public', false)`;
+    await tx`SELECT pg_catalog.set_config('app.current_user_id', '00000000-0000-0000-0000-000000000000', true)`;
+    await tx`SELECT pg_catalog.set_config('app.current_user_role', 'admin', true)`;
+    await tx`SELECT pg_catalog.set_config('app.current_workspace_id', '', true)`;
     const nowIso = new Date().toISOString();
-    const docIdLiteral = JSON.stringify(documentId);
-    const nowLiteral = JSON.stringify(nowIso);
-    await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$
-				MERGE (d:Document {id: ${docIdLiteral}})
-				SET d.created_at = ${nowLiteral}, d.entity_extracted_at = ${nowLiteral}
-				RETURN d.id
-			$$) AS (result agtype)`);
-    for (const ent of entities) {
-      const label = ent.type;
-      const name = ent.name;
-      const conf = ent.confidence;
-      await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${entityUpsertCypher(documentId, label, name, nowIso, conf)} $$) AS (result agtype)`);
-      await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${documentEntityEdgeCypher(documentId, label, name, conf)} $$) AS (result agtype)`);
-    }
-    for (const ent of entities) {
-      for (const rel of ent.relationships) {
-        const cypher = entityRelationCypher(ent.type, ent.name, rel.targetName, rel.relationType, rel.confidence);
-        await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${cypher} $$) AS (result agtype)`);
+    await runGenerationFencedGraphWrite({
+      async lockCurrentGeneration() {
+        const rows = await tx`
+					SELECT d.id
+					FROM public.documents d
+					JOIN public.document_pipeline_runs r
+					  ON r.document_id = d.id
+					 AND r.generation_id = ${identity.generationId}::uuid
+					WHERE d.id = ${documentId}::uuid
+					  AND d.active_embedding_generation = ${identity.generationId}::uuid
+					  AND d.content_hash = ${identity.revision}
+					  AND r.revision = ${identity.revision}
+					  AND r.status NOT IN ('cancelled', 'failed')
+					  AND r.graph_status = 'processing'
+					FOR UPDATE OF d, r
+				`;
+        return rows.length === 1;
+      },
+      async persist() {
+        for (const cypher of graphReplacementCyphers({
+          documentId,
+          generationId: identity.generationId,
+          revision: identity.revision,
+          timestamp: nowIso
+        })) {
+          await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${cypher} $$) AS (result agtype)`);
+        }
+        for (const ent of entities) {
+          const label = ent.type;
+          const name = ent.name;
+          const conf = ent.confidence;
+          await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${entityUpsertCypher(documentId, label, name, nowIso, conf)} $$) AS (result agtype)`);
+          await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${documentEntityEdgeCypher(documentId, identity.generationId, label, name, conf)} $$) AS (result agtype)`);
+        }
+        for (const ent of entities) {
+          for (const rel of ent.relationships) {
+            const cypher = entityRelationCypher(documentId, identity.generationId, ent.type, ent.name, rel.targetName, rel.relationType, rel.confidence);
+            await tx.unsafe(`SELECT * FROM cypher('docs_graph', $$ ${cypher} $$) AS (result agtype)`);
+          }
+        }
       }
-    }
+    });
   });
 }
 function entityUpsertCypher(docId, label, name, nowIso, confidence) {
@@ -233065,27 +233479,118 @@ function entityUpsertCypher(docId, label, name, nowIso, confidence) {
 		MERGE (e:\`${label}\` {name: $name})
 		SET e.created_at = $now, e.last_seen_doc = $docId, e.confidence = $conf
 		RETURN e.name
-	`.replace("$name", JSON.stringify(name)).replace("$now", JSON.stringify(nowIso)).replace("$docId", JSON.stringify(docId)).replace("$conf", confLiteral);
+	`.replaceAll("$name", JSON.stringify(name)).replaceAll("$now", JSON.stringify(nowIso)).replaceAll("$docId", JSON.stringify(docId)).replaceAll("$conf", confLiteral);
 }
-function documentEntityEdgeCypher(docId, label, name, confidence) {
+function documentEntityEdgeCypher(docId, generationId, label, name, confidence) {
   const confLiteral = typeof confidence === "number" ? JSON.stringify(confidence) : "null";
   return `
 		MATCH (d:Document {id: $docId})
 		MATCH (e:\`${label}\` {name: $name})
-		MERGE (d)-[r:MENTIONS]->(e)
-		SET r.created_at = $now, r.confidence = $conf
+		MERGE (d)-[r:MENTIONS {document_id: $docId}]->(e)
+		SET r.created_at = $now, r.confidence = $conf, r.generation_id = $generationId
 		RETURN r
-	`.replace("$docId", JSON.stringify(docId)).replace("$name", JSON.stringify(name)).replace("$now", JSON.stringify(new Date().toISOString())).replace("$conf", confLiteral);
+	`.replaceAll("$docId", JSON.stringify(docId)).replaceAll("$name", JSON.stringify(name)).replaceAll("$now", JSON.stringify(new Date().toISOString())).replaceAll("$generationId", JSON.stringify(generationId)).replaceAll("$conf", confLiteral);
 }
-function entityRelationCypher(sourceLabel, sourceName, targetName, relationType, confidence) {
+function entityRelationCypher(documentId, generationId, sourceLabel, sourceName, targetName, relationType, confidence) {
   const confLiteral = typeof confidence === "number" ? JSON.stringify(confidence) : "null";
   return `
 		MATCH (a:\`${sourceLabel}\` {name: $source})
 		MATCH (b {name: $target})
-		MERGE (a)-[r:\`${relationType}\`]->(b)
-		SET r.created_at = $now, r.confidence = $conf
+		MERGE (a)-[r:\`${relationType}\` {document_id: $documentId}]->(b)
+		SET r.created_at = $now, r.confidence = $conf, r.generation_id = $generationId
 		RETURN r
-	`.replace("$source", JSON.stringify(sourceName)).replace("$target", JSON.stringify(targetName)).replace("$now", JSON.stringify(new Date().toISOString())).replace("$conf", confLiteral);
+	`.replaceAll("$source", JSON.stringify(sourceName)).replaceAll("$target", JSON.stringify(targetName)).replaceAll("$documentId", JSON.stringify(documentId)).replaceAll("$generationId", JSON.stringify(generationId)).replaceAll("$now", JSON.stringify(new Date().toISOString())).replaceAll("$conf", confLiteral);
+}
+
+// ../../backend/src/lib/knowledge-summary.ts
+async function runKnowledgeSummaryStage(dependencies) {
+  const document2 = await dependencies.readCurrent();
+  if (!document2)
+    return "cancelled";
+  const summary = await dependencies.generate(document2);
+  if (summary.status === "skipped")
+    return "skipped";
+  return await dependencies.persistIfCurrent(summary) ? "ready" : "cancelled";
+}
+async function buildKnowledgeSummary(document2, provider) {
+  if (!document2.content.trim()) {
+    return { status: "skipped", reason: "empty_document" };
+  }
+  const output = await provider(document2);
+  if (!output)
+    throw new Error("summary_provider_failed");
+  const language = output.language.trim();
+  const description = output.description.trim();
+  if (!language || !description)
+    throw new Error("summary_provider_invalid");
+  const seen = new Set;
+  const keywords = [];
+  for (const raw of output.keywords) {
+    const keyword = raw.trim();
+    const key = keyword.toLocaleLowerCase("en");
+    if (!keyword || seen.has(key))
+      continue;
+    seen.add(key);
+    keywords.push(keyword);
+    if (keywords.length === 20)
+      break;
+  }
+  return {
+    status: "ready",
+    language,
+    description,
+    keywords,
+    model: output.model
+  };
+}
+
+// ../../backend/src/lib/knowledge-summary-provider.ts
+init_zod();
+init_config();
+var summarySchema = exports_external2.object({
+  language: exports_external2.string().min(1).max(32),
+  description: exports_external2.string().min(1).max(2000),
+  keywords: exports_external2.array(exports_external2.string().min(1).max(100)).max(20)
+});
+var systemPrompt = [
+  "Summarize a knowledge-base document for retrieval metadata.",
+  "Return only JSON with language, description, and keywords.",
+  "Use a concise factual description and at most 20 distinct keywords."
+].join(`
+`);
+function provider(baseUrl, apiKey, model) {
+  if (!baseUrl || !model)
+    return;
+  return {
+    baseUrl,
+    model,
+    apiKey: resolveChatProviderKey(baseUrl, apiKey, config3.OPENROUTER_API_KEY),
+    timeoutMs: config3.GRAPH_EXTRACT_TIMEOUT_MS,
+    reasoningEffort: config3.GRAPH_EXTRACT_REASONING_EFFORT
+  };
+}
+async function requestKnowledgeSummary(document2) {
+  const primary = provider(config3.GRAPH_EXTRACT_BASE_URL, config3.GRAPH_EXTRACT_API_KEY, config3.GRAPH_EXTRACT_MODEL);
+  if (!primary)
+    return null;
+  const fallback = provider(config3.GRAPH_EXTRACT_FALLBACK_BASE_URL, config3.GRAPH_EXTRACT_FALLBACK_API_KEY, config3.GRAPH_EXTRACT_FALLBACK_MODEL);
+  const result = await requestStructuredChat({
+    primary,
+    fallback,
+    messages: [
+      { role: "system", content: systemPrompt },
+      {
+        role: "user",
+        content: `Title: ${document2.title}
+
+${document2.content.slice(0, 50000)}`
+      }
+    ],
+    outputSchema: summarySchema,
+    maxTokens: 768,
+    temperature: 0
+  });
+  return result ? { ...result.data, model: result.model } : null;
 }
 
 // ../../backend/src/queue/document-revision.ts
@@ -233263,6 +233768,23 @@ async function getRun(generationId) {
     return run4 ?? null;
   });
 }
+async function isCurrentPipelineGeneration(job2) {
+  return withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
+    const [current] = await tx.select({ id: documents.id }).from(documents).innerJoin(documentPipelineRuns, and(eq(documentPipelineRuns.documentId, documents.id), eq(documentPipelineRuns.generationId, job2.generationId))).where(and(eq(documents.id, job2.documentId), eq(documents.activeEmbeddingGeneration, job2.generationId), eq(documentPipelineRuns.revision, job2.revision), ne(documentPipelineRuns.status, "cancelled"), ne(documentPipelineRuns.status, "failed"), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1);
+    return Boolean(current);
+  });
+}
+async function cancelStalePipelineRun(job2) {
+  await withTenant(admin, (tx) => tx.update(documentPipelineRuns).set({
+    status: "cancelled",
+    graphStatus: "cancelled",
+    summarizeStatus: "cancelled",
+    finalizeStatus: "cancelled",
+    errorCode: "stale_revision",
+    completedAt: new Date,
+    updatedAt: new Date
+  }).where(and(eq(documentPipelineRuns.generationId, job2.generationId), ne(documentPipelineRuns.status, "cancelled"))));
+}
 async function setStageStatus(generationId, stage, status2, errorCode) {
   await withTenant(admin, (tx) => tx.update(documentPipelineRuns).set({
     ...stagePatch(stage, status2),
@@ -233518,18 +234040,22 @@ function createPipelineStageDependencies(redisUrl) {
       },
       async extract(job2) {
         const doc5 = await withTenant(admin, async (tx) => {
-          const [row] = await tx.select({ content: documents.content }).from(documents).where(and(eq(documents.id, job2.documentId), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1);
+          const [row] = await tx.select({ content: documents.content }).from(documents).where(and(eq(documents.id, job2.documentId), eq(documents.activeEmbeddingGeneration, job2.generationId), eq(documents.contentHash, job2.revision), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1);
           return row;
         });
         if (!doc5)
           throw new Error("Pipeline document not found");
-        await withProviderPermit(providerProfile(`graph:${config3.GRAPH_EXTRACT_MODEL ?? "default"}`), "graph", () => extractEntities(doc5.content ?? "", job2.documentId));
+        await withProviderPermit(providerProfile(`graph:${config3.GRAPH_EXTRACT_MODEL ?? "default"}`), "graph", () => extractEntities(doc5.content ?? "", job2.documentId, {
+          generationId: job2.generationId,
+          revision: job2.revision
+        }));
       },
       async compensateExtract(job2) {
         const owned = await withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => tx.select({ id: documents.id }).from(documents).where(and(eq(documents.id, job2.documentId), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1));
         if (owned.length === 1)
-          await deleteDocumentGraphState(job2.documentId);
+          await deleteDocumentGraphGeneration(job2.documentId, job2.generationId);
       },
+      cancelStaleRun: cancelStalePipelineRun,
       setGraphStatus: (generationId, status2, errorCode) => setStageStatus(generationId, "graph", status2, errorCode),
       async enqueueSummarize(job2) {
         const data = { ...job2, stage: "summarize" };
@@ -233542,6 +234068,8 @@ function createPipelineStageDependencies(redisUrl) {
     },
     summarize: {
       isCancelled: async (job2) => (await getRun(job2.generationId))?.status === "cancelled",
+      isCurrent: isCurrentPipelineGeneration,
+      cancelStaleRun: cancelStalePipelineRun,
       async getRun(job2) {
         const run4 = await getRun(job2.generationId);
         return run4 ? {
@@ -233552,8 +234080,59 @@ function createPipelineStageDependencies(redisUrl) {
           embedStatus: pipelineStageStatus(run4.embedStatus)
         } : null;
       },
-      enabled: () => false,
-      async summarize() {},
+      enabled: () => config3.GRAPH_EXTRACT_ENABLED && Boolean(config3.GRAPH_EXTRACT_BASE_URL && config3.GRAPH_EXTRACT_MODEL),
+      async summarize(job2) {
+        return runKnowledgeSummaryStage({
+          readCurrent: () => withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
+            const [document2] = await tx.select({
+              title: documents.title,
+              content: documents.content,
+              contentHash: documents.contentHash,
+              activeGeneration: documents.activeEmbeddingGeneration
+            }).from(documents).where(and(eq(documents.id, job2.documentId), eq(documents.activeEmbeddingGeneration, job2.generationId), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1);
+            if (!document2)
+              return null;
+            const revision = resolveDocumentRevision(document2.contentHash, document2.title, document2.content ?? "");
+            if (revision !== job2.revision)
+              return null;
+            return {
+              title: document2.title,
+              content: document2.content ?? "",
+              revision
+            };
+          }),
+          generate: (document2) => buildKnowledgeSummary(document2, requestKnowledgeSummary),
+          persistIfCurrent: (summary) => withTenant({ ...admin, workspaceId: job2.workspaceId }, async (tx) => {
+            const [current] = await tx.select({ id: documents.id }).from(documents).innerJoin(documentPipelineRuns, and(eq(documentPipelineRuns.documentId, documents.id), eq(documentPipelineRuns.generationId, job2.generationId))).where(and(eq(documents.id, job2.documentId), eq(documents.activeEmbeddingGeneration, job2.generationId), eq(documents.contentHash, job2.revision), eq(documentPipelineRuns.revision, job2.revision), eq(documentPipelineRuns.summarizeStatus, "processing"), ne(documentPipelineRuns.status, "cancelled"), ne(documentPipelineRuns.status, "failed"), tenantOwnerCondition(documents.ownerId, documents.workspaceId, jobTenant(job2)))).limit(1).for("update");
+            if (!current)
+              return false;
+            await tx.insert(documentKnowledgeSummaries).values({
+              document_id: job2.documentId,
+              owner_id: job2.ownerId,
+              workspace_id: job2.workspaceId,
+              generation_id: job2.generationId,
+              revision: job2.revision,
+              language: summary.language,
+              description: summary.description,
+              keywords: summary.keywords,
+              updated_at: new Date
+            }).onConflictDoUpdate({
+              target: [
+                documentKnowledgeSummaries.document_id,
+                documentKnowledgeSummaries.generation_id
+              ],
+              set: {
+                revision: job2.revision,
+                language: summary.language,
+                description: summary.description,
+                keywords: summary.keywords,
+                updated_at: new Date
+              }
+            });
+            return true;
+          })
+        });
+      },
       setSummaryStatus: (generationId, status2, errorCode) => setStageStatus(generationId, "summarize", status2, errorCode),
       async enqueueFinalize(job2) {
         const data = { ...job2, stage: "finalize" };
@@ -233938,10 +234517,8 @@ function createEmbedWorker(redisUrl, deps, options = {}) {
   });
 }
 
-// ../../backend/src/queue/workers/finalize.worker.ts
+// ../../backend/src/queue/stage-policies.ts
 function deriveFinalStatus(run4) {
-  if (!run4)
-    throw new Error("Pipeline run not found");
   if (run4.status === "cancelled")
     return "cancelled";
   if (run4.embedStatus === "failed" || run4.embedStatus === "cancelled")
@@ -233956,6 +234533,96 @@ function deriveFinalStatus(run4) {
   }
   return "failed";
 }
+async function processSummaryStage(job2, dependencies) {
+  const isExplicitlyCancelled = async () => await dependencies.isCancelled?.(job2) === true;
+  const hasCurrentGeneration = async () => await dependencies.isCurrent?.(job2) !== false;
+  const continueIfCurrent = async () => {
+    if (await isExplicitlyCancelled())
+      return false;
+    if (await hasCurrentGeneration())
+      return true;
+    await dependencies.cancelStaleRun?.(job2);
+    return false;
+  };
+  if (!await continueIfCurrent())
+    return;
+  const run4 = await dependencies.getRun(job2);
+  if (!run4)
+    throw new Error("Pipeline run not found");
+  if (run4.ownerId !== job2.ownerId || run4.documentId !== job2.documentId) {
+    throw new Error("Pipeline owner mismatch");
+  }
+  if (run4.generationId !== job2.generationId || run4.revision !== job2.revision) {
+    await dependencies.setSummaryStatus(job2.generationId, "cancelled", "stale_revision");
+    await dependencies.cancelStaleRun?.(job2);
+    return;
+  }
+  if (!dependencies.enabled()) {
+    if (!await continueIfCurrent())
+      return;
+    await dependencies.setSummaryStatus(job2.generationId, "skipped");
+    if (!await continueIfCurrent())
+      return;
+    await dependencies.enqueueFinalize(job2);
+    return;
+  }
+  if (!await continueIfCurrent())
+    return;
+  await dependencies.setSummaryStatus(job2.generationId, "processing");
+  try {
+    if (!await continueIfCurrent())
+      return;
+    const status2 = await dependencies.summarize(job2);
+    if (status2 === "cancelled") {
+      if (await isExplicitlyCancelled()) {
+        await dependencies.setSummaryStatus(job2.generationId, "cancelled");
+        return;
+      }
+      await dependencies.setSummaryStatus(job2.generationId, "cancelled", "stale_revision");
+      await dependencies.cancelStaleRun?.(job2);
+      return;
+    }
+    if (await isExplicitlyCancelled()) {
+      await dependencies.setSummaryStatus(job2.generationId, "cancelled");
+      return;
+    }
+    if (!await hasCurrentGeneration()) {
+      if (await isExplicitlyCancelled())
+        return;
+      await dependencies.setSummaryStatus(job2.generationId, "cancelled", "stale_revision");
+      await dependencies.cancelStaleRun?.(job2);
+      return;
+    }
+    await dependencies.setSummaryStatus(job2.generationId, status2);
+  } catch (error53) {
+    if (!await continueIfCurrent())
+      return;
+    await dependencies.setSummaryStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "summary_failed");
+    if (!await continueIfCurrent())
+      return;
+    await dependencies.enqueueFinalize(job2);
+    return;
+  }
+  if (!await continueIfCurrent())
+    return;
+  await dependencies.enqueueFinalize(job2);
+}
+async function processGraphStageFailure(job2, error53, dependencies) {
+  if (isStaleRevisionError(error53)) {
+    await dependencies.setGraphStatus(job2.generationId, "cancelled", "stale_revision");
+    await dependencies.cancelStaleRun(job2);
+    return;
+  }
+  if (await dependencies.isCancelled?.(job2))
+    throw error53;
+  await dependencies.setGraphStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "graph_failed");
+  if (!await dependencies.isCancelled?.(job2)) {
+    await dependencies.enqueueSummarize(job2);
+  }
+  throw error53;
+}
+
+// ../../backend/src/queue/workers/finalize.worker.ts
 function createFinalizeWorker(deps) {
   return async function processFinalizeJob(input) {
     const job2 = finalizeJobSchema.parse(input);
@@ -233987,6 +234654,7 @@ function createGraphWorker(deps) {
     }
     if (run4.generationId !== job2.generationId || run4.revision !== job2.revision) {
       await deps.setGraphStatus(job2.generationId, "cancelled", "stale_revision");
+      await deps.cancelStaleRun(job2);
       return;
     }
     if (run4.embedStatus !== "ready") {
@@ -234012,12 +234680,7 @@ function createGraphWorker(deps) {
       if (!await deps.isCancelled?.(job2))
         await deps.enqueueSummarize(job2);
     } catch (error53) {
-      if (await deps.isCancelled?.(job2))
-        throw error53;
-      await deps.setGraphStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "graph_failed");
-      if (!await deps.isCancelled?.(job2))
-        await deps.enqueueSummarize(job2);
-      throw error53;
+      await processGraphStageFailure(job2, error53, deps);
     }
   };
 }
@@ -234088,44 +234751,7 @@ function createPrepareWorker(redisUrl, deps, options = {}) {
 function createSummarizeWorker(deps) {
   return async function processSummarizeJob(input) {
     const job2 = summarizeJobSchema.parse(input);
-    if (await deps.isCancelled?.(job2))
-      return;
-    const run4 = await deps.getRun(job2);
-    if (!run4)
-      throw new Error("Pipeline run not found");
-    if (run4.ownerId !== job2.ownerId || run4.documentId !== job2.documentId) {
-      throw new Error("Pipeline owner mismatch");
-    }
-    if (run4.generationId !== job2.generationId || run4.revision !== job2.revision) {
-      await deps.setSummaryStatus(job2.generationId, "cancelled", "stale_revision");
-      return;
-    }
-    if (!deps.enabled()) {
-      if (await deps.isCancelled?.(job2))
-        return;
-      await deps.setSummaryStatus(job2.generationId, "skipped");
-      if (!await deps.isCancelled?.(job2))
-        await deps.enqueueFinalize(job2);
-      return;
-    }
-    if (await deps.isCancelled?.(job2))
-      return;
-    await deps.setSummaryStatus(job2.generationId, "processing");
-    try {
-      if (await deps.isCancelled?.(job2))
-        return;
-      await deps.summarize(job2);
-      if (await deps.isCancelled?.(job2))
-        return;
-      await deps.setSummaryStatus(job2.generationId, "ready");
-    } catch (error53) {
-      if (await deps.isCancelled?.(job2))
-        return;
-      await deps.setSummaryStatus(job2.generationId, "failed", error53 instanceof Error ? error53.name : "summary_failed");
-      throw error53;
-    }
-    if (!await deps.isCancelled?.(job2))
-      await deps.enqueueFinalize(job2);
+    await processSummaryStage(job2, deps);
   };
 }
 
@@ -234265,6 +234891,7 @@ var pipelineRuntime = await startRegisteredPipelineWorkers({
     logger3.info({ legacy, recovery }, "Pipeline recovery completed");
   }
 });
+var reembedCronRuntime = startReembedCron();
 ensureBucket(storage, BUCKET).catch((err) => {
   logger3.error({ err }, "Failed to ensure storage bucket");
 });
@@ -234319,7 +234946,7 @@ var swaggerConfig = {
     },
     info: {
       title: "DocsMint API",
-      version: "0.6.0",
+      version: "0.6.2",
       description: "Self-hosted AI-first documentation platform. Full-text + semantic search, version history, sharing, and folder organization.",
       contact: { name: "HiAi-gg", url: "https://github.com/HiAi-gg/docsmint" },
       license: {
@@ -234390,6 +235017,7 @@ app.listen({
 logger3.info({ port: config3.API_PORT }, "hiai-docs API started");
 var stopDocsMintApi = async () => {
   logger3.info("Shutting down...");
+  reembedCronRuntime.close();
   await pipelineRuntime.close();
   await app.stop();
 };