@agent-native/core 0.187.0-nightly-20260924172231 → 0.187.0

package/corpus/templates/brain/server/lib/search-index.ts

@@ -3,6 +3,7 @@ import {
   availableEmbeddingFamilies,
   defaultEmbeddingFamily,
   type EmbeddingFamily,
+  readEmbeddingFamilyAvailability,
 } from "@agent-native/core/embeddings";
 import {
   deletePgVectors,
@@ -39,6 +40,25 @@ export const BRAIN_MAX_EMBEDDED_BURSTS = 12;
 
 export type BrainSearchArtifact = z.infer<typeof artifactSchema>;
 
+export type BrainEmbeddingReadinessStatus =
+  | "ready"
+  | "not-configured"
+  | "ambiguous"
+  | "unavailable";
+
+export interface BrainEmbeddingReadiness {
+  status: BrainEmbeddingReadinessStatus;
+  ready: boolean;
+  configuredProviders: string[];
+  unavailableProviders: string[];
+  configuredFamilies: number;
+  provider: string | null;
+  model: string | null;
+  embeddingSetId: string | null;
+  dimensions: number | null;
+  warning: string | null;
+}
+
 export interface SearchIndexCapture {
   id: string;
   sourceId: string;
@@ -245,11 +265,225 @@ export function burstRows(
   return rows;
 }
 
+export function embeddingReadinessFromFamilies(
+  families: readonly EmbeddingFamily[],
+  unavailableProviders: readonly string[] = [],
+): BrainEmbeddingReadiness {
+  const configuredProviders = Array.from(
+    new Set(families.map((candidate) => candidate.provider)),
+  );
+  if (unavailableProviders.length) {
+    return {
+      status: "unavailable",
+      ready: false,
+      configuredProviders,
+      unavailableProviders: [...unavailableProviders],
+      configuredFamilies: families.length,
+      provider: null,
+      model: null,
+      embeddingSetId: null,
+      dimensions: null,
+      warning:
+        "Embedding credential status is temporarily unavailable. Retry before indexing.",
+    };
+  }
+  const family = defaultEmbeddingFamily(families);
+  if (family) {
+    return {
+      status: "ready",
+      ready: true,
+      configuredProviders: [family.provider],
+      unavailableProviders: [],
+      configuredFamilies: 1,
+      provider: family.provider,
+      model: family.model,
+      embeddingSetId: family.id,
+      dimensions: family.dimensions,
+      warning: null,
+    };
+  }
+  return {
+    status: families.length ? "ambiguous" : "not-configured",
+    ready: false,
+    configuredProviders,
+    unavailableProviders: [],
+    configuredFamilies: families.length,
+    provider: null,
+    model: null,
+    embeddingSetId: null,
+    dimensions: null,
+    warning: families.length
+      ? "Configure exactly one embedding provider."
+      : "Configure one embedding provider to enable semantic retrieval.",
+  };
+}
+
+export async function readEmbeddingReadiness(): Promise<BrainEmbeddingReadiness> {
+  const availability = await readEmbeddingFamilyAvailability();
+  return embeddingReadinessFromFamilies(
+    availability.families,
+    availability.unavailableProviders,
+  );
+}
+
 async function configuredEmbeddingFamily(): Promise<EmbeddingFamily | null> {
   const families = await availableEmbeddingFamilies();
   return defaultEmbeddingFamily(families);
 }
 
+export interface CaptureEmbeddingCoverage {
+  complete: boolean;
+  artifactEmbedded: boolean;
+  expectedBursts: number;
+  embeddedBursts: number;
+}
+
+export function captureAudienceIndexingFailureReason(
+  assignments: readonly unknown[],
+): "no-active-audience" | "multiple-audience-assignments" | null {
+  if (!assignments.length) return "no-active-audience";
+  return assignments.length === 1 ? null : "multiple-audience-assignments";
+}
+
+export function captureEmbeddingCoverageFromTargets(input: {
+  artifactId: string;
+  burstIds: string[];
+  embeddings: Array<{ targetType: string; targetId: string }>;
+}): CaptureEmbeddingCoverage {
+  const embeddedTargets = new Set(
+    input.embeddings.map((row) => `${row.targetType}:${row.targetId}`),
+  );
+  const artifactEmbedded = embeddedTargets.has(`artifact:${input.artifactId}`);
+  const embeddedBursts = input.burstIds.filter((id) =>
+    embeddedTargets.has(`burst:${id}`),
+  ).length;
+  return {
+    complete: artifactEmbedded && embeddedBursts === input.burstIds.length,
+    artifactEmbedded,
+    expectedBursts: input.burstIds.length,
+    embeddedBursts,
+  };
+}
+
+export async function readCaptureEmbeddingCoverage(
+  captureId: string,
+  embeddingSetId: string,
+): Promise<CaptureEmbeddingCoverage> {
+  const db = getDb();
+  const assignments = await db
+    .select({
+      audienceId: schema.brainCaptureAudiences.audienceId,
+      aclHash: schema.brainCaptureAudiences.aclHash,
+    })
+    .from(schema.brainCaptureAudiences)
+    .where(eq(schema.brainCaptureAudiences.captureId, captureId));
+  if (captureAudienceIndexingFailureReason(assignments)) {
+    return {
+      complete: false,
+      artifactEmbedded: false,
+      expectedBursts: 0,
+      embeddedBursts: 0,
+    };
+  }
+  const assignment = assignments[0]!;
+  const [artifact] = await db
+    .select({
+      id: schema.brainSearchArtifacts.id,
+      contentHash: schema.brainSearchArtifacts.contentHash,
+      sensitivityPolicyVersion:
+        schema.brainSearchArtifacts.sensitivityPolicyVersion,
+      aclHash: schema.brainSearchArtifacts.aclHash,
+      indexVersion: schema.brainSearchArtifacts.indexVersion,
+    })
+    .from(schema.brainSearchArtifacts)
+    .innerJoin(
+      schema.brainRawCaptures,
+      eq(schema.brainSearchArtifacts.captureId, schema.brainRawCaptures.id),
+    )
+    .where(
+      and(
+        eq(schema.brainRawCaptures.id, captureId),
+        eq(schema.brainRawCaptures.sensitivityDisposition, "allowed"),
+        eq(schema.brainSearchArtifacts.status, "active"),
+        eq(schema.brainSearchArtifacts.audienceId, assignment.audienceId),
+        eq(schema.brainSearchArtifacts.aclHash, assignment.aclHash),
+        eq(
+          schema.brainSearchArtifacts.contentHash,
+          schema.brainRawCaptures.contentHash,
+        ),
+        eq(
+          schema.brainSearchArtifacts.sensitivityPolicyVersion,
+          schema.brainRawCaptures.sensitivityPolicyVersion,
+        ),
+        eq(
+          schema.brainSearchArtifacts.aclHash,
+          schema.brainRawCaptures.audienceAclHash,
+        ),
+        eq(
+          schema.brainSearchArtifacts.indexVersion,
+          BRAIN_SEARCH_INDEX_VERSION,
+        ),
+      ),
+    )
+    .limit(1);
+  if (!artifact) {
+    return {
+      complete: false,
+      artifactEmbedded: false,
+      expectedBursts: 0,
+      embeddedBursts: 0,
+    };
+  }
+  const bursts = await db
+    .select({ id: schema.brainSearchBursts.id })
+    .from(schema.brainSearchBursts)
+    .where(
+      and(
+        eq(schema.brainSearchBursts.artifactId, artifact.id),
+        eq(schema.brainSearchBursts.indexed, 1),
+        eq(schema.brainSearchBursts.contentHash, artifact.contentHash),
+        eq(schema.brainSearchBursts.indexVersion, artifact.indexVersion),
+      ),
+    );
+  const targetIds = [artifact.id, ...bursts.map((burst) => burst.id)];
+  const embeddings = await db
+    .select({
+      targetType: schema.brainSearchEmbeddings.targetType,
+      targetId: schema.brainSearchEmbeddings.targetId,
+    })
+    .from(schema.brainSearchEmbeddings)
+    .where(
+      and(
+        eq(schema.brainSearchEmbeddings.status, "active"),
+        eq(schema.brainSearchEmbeddings.embeddingSetId, embeddingSetId),
+        eq(schema.brainSearchEmbeddings.contentHash, artifact.contentHash),
+        eq(
+          schema.brainSearchEmbeddings.sensitivityPolicyVersion,
+          artifact.sensitivityPolicyVersion,
+        ),
+        eq(schema.brainSearchEmbeddings.aclHash, artifact.aclHash),
+        eq(schema.brainSearchEmbeddings.indexVersion, artifact.indexVersion),
+        inArray(schema.brainSearchEmbeddings.targetId, targetIds),
+      ),
+    );
+  return captureEmbeddingCoverageFromTargets({
+    artifactId: artifact.id,
+    burstIds: bursts.map((burst) => burst.id),
+    embeddings,
+  });
+}
+
+export async function embedSearchTexts(
+  family: EmbeddingFamily | null,
+  texts: string[],
+): Promise<number[][] | null> {
+  if (!family) return null;
+  return family.embed(
+    texts.map((text) => ({ text })),
+    "document",
+  );
+}
+
 async function indexExternalSearchLanes(input: {
   artifactId: string;
   artifact: BrainSearchArtifact;
@@ -276,7 +510,6 @@ async function indexExternalSearchLanes(input: {
     namespace: SEARCH_NAMESPACE,
   });
   const family = await configuredEmbeddingFamily();
-  if (!family || !true) return;
   const targets = [
     {
       targetType: "artifact" as const,
@@ -291,10 +524,11 @@ async function indexExternalSearchLanes(input: {
       text: input.burstBodies[index] ?? "",
     })),
   ].filter((target) => target.text.trim());
-  const vectors = await family.embed(
-    targets.map((target) => ({ text: target.text })),
-    "document",
+  const vectors = await embedSearchTexts(
+    family,
+    targets.map((target) => target.text),
   );
+  if (!family || !vectors) return;
   await ensurePgVectorIndex(dbExec, family.dimensions, {
     namespace: SEARCH_NAMESPACE,
   });
@@ -633,20 +867,23 @@ export async function indexBrainCapture(captureId: string): Promise<{
     })
     .from(schema.brainCaptureAudiences)
     .where(eq(schema.brainCaptureAudiences.captureId, captureId));
-  let indexed = 0;
-  for (const audience of audiences) {
-    const result = await indexCaptureForSearch({
-      capture: {
-        ...capture,
-        sensitivityDisposition: capture.sensitivityDisposition,
-      },
-      audience,
-      id: nanoid(),
-      now: nowIso(),
-    });
-    if (result.indexed) indexed += 1;
+  const audienceFailure = captureAudienceIndexingFailureReason(audiences);
+  if (audienceFailure) {
+    await unindexBrainCapture(captureId);
+    return { indexed: 0, reason: audienceFailure };
   }
-  return indexed ? { indexed } : { indexed: 0, reason: "no-active-audience" };
+  const result = await indexCaptureForSearch({
+    capture: {
+      ...capture,
+      sensitivityDisposition: capture.sensitivityDisposition,
+    },
+    audience: audiences[0]!,
+    id: nanoid(),
+    now: nowIso(),
+  });
+  return result.indexed
+    ? { indexed: 1 }
+    : { indexed: 0, reason: result.reason ?? "search-index-failed" };
 }
 
 export async function unindexBrainCapture(captureId: string): Promise<void> {

package/corpus/templates/brain/server/lib/search.ts

@@ -298,6 +298,33 @@ export function buildSnippet(
   return buildSearchSnippet(value, terms, maxLength);
 }
 
+export function citationEvidenceMatchesCapture(
+  citation:
+    | {
+        quote?: string | null;
+        preview?: string | null;
+        verbatim?: boolean;
+      }
+    | null
+    | undefined,
+  captureContent: string,
+) {
+  const redactedContent = redactSensitiveText(captureContent)
+    .replace(/\s+/g, " ")
+    .trim();
+  const quote = citation?.quote?.trim();
+  if (quote) return captureContent.includes(quote);
+  if (citation?.verbatim !== false) return false;
+  const preview = citation.preview
+    ?.trim()
+    .replace(/^\.\.\./, "")
+    .replace(/\.\.\.$/, "")
+    .trim()
+    .replace(/\s+/g, " ");
+  if (!preview) return false;
+  return redactedContent.includes(preview);
+}
+
 export function scoreSearchText(
   fields: {
     title?: string | null;

package/corpus/templates/calendar/CHANGELOG.md

@@ -9,6 +9,12 @@ time from the command menu (Cmd+K → "What's new") or from Settings.
 
 - Calendar opens faster by loading translated catalogs only when you need them.
 
+### Fixed
+
+- Bookings no longer confirm without their configured Zoom meeting
+- Release a booking slot when Zoom creation never starts
+- Zoom booking timeouts keep the slot reserved to prevent duplicate meetings.
+
 ## 2026-09-22
 
 ### Improved

package/corpus/templates/clips/CHANGELOG.md

@@ -7,10 +7,19 @@ from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Improved
 
+- Clip share sidebars stay expanded in stacked layouts and use a floating, borderless control when collapsed.
+- Clip viewers can collapse the comments, transcript, and Agent sidebar
+- Search results clarify where a match appears in the video.
+- Search results show where a transcript or comment match appears
 - Insights charts load only when opened, keeping the recording library faster.
 
 ### Fixed
 
+- Comment fields grow as you type so longer messages stay visible
+- New recordings stay loading until their share is available
+- Playback errors no longer cover the video player controls
+- Trash recordings are excluded from search results.
+- Opening a trashed recording now links its breadcrumb back to Trash.
 - Long recording menus scroll within the visible space so every action stays reachable.
 
 ## 2026-09-22
@@ -28,6 +37,7 @@ from the command menu (Cmd+K → "What's new") or from Settings.
 
 ### Fixed
 
+- Stopped Clips AI actions now clear the in-progress status.
 - Clips keeps uploaded videos visible while the library refreshes and localizes Loom import failures.
 - Clips recovers dropped uploads after a lost finalization response and clears saving feedback after successful saves.
 - The desktop app stops re-checking flags and meetings every few seconds after your session expires, and resumes when you sign in again.

package/corpus/templates/content/CHANGELOG.md

@@ -3,6 +3,28 @@
 All notable user-facing changes to Agent-Native Content are documented here. Open it any
 time from the command menu (Cmd+K → "What's new").
 
+## 2026-09-23
+
+### Added
+
+- Every page in the sidebar now has a "…" menu to rename, duplicate, move, copy its link, open it in a new tab, or move it to Trash, and it shows who last edited the page. Duplicate copies sub-pages too, and Move can take a page and its sub-pages to another workspace after warning you that its sharing will change.
+
+### Improved
+
+- The sidebar is easier to scan: the page you're on is highlighted wherever it appears, nested pages show guide lines and Trash stays in reach below the page list.
+
+### Fixed
+
+- Tables inserted in the visual editor now let you resize columns.
+- Markdown tables with aligned columns now open as editable tables in pages, keeping column alignment and all cell content.
+- The Trash view no longer highlights a document that is not in Trash.
+
+## 2026-09-22
+
+### Fixed
+
+- Comments, replies, and suggested-edit decisions now appear immediately without leaving duplicate text in the composer while they save.
+
 ## 2026-09-21
 
 ### Improved