@agent-native/core 0.161.20 → 0.161.22

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8314
+- template files: 8320

package/corpus/templates/clips/actions/finalize-meeting.ts

@@ -95,6 +95,7 @@ export default defineAction({
     // stale (see PENDING_STALE_MS). A fresh 'pending' row may still be an
     // active text-model run, so it is left alone.
     const staleBefore = new Date(Date.now() - PENDING_STALE_MS).toISOString();
+    const claimUpdatedAt = nowIso;
     const claimPredicate = args.force
       ? or(
           inArray(schema.meetings.transcriptStatus, ["ready", "failed"]),
@@ -241,10 +242,13 @@ export default defineAction({
 
     // Single transaction so the meetings write and the action-items
     // delete+insert can't interleave with a second concurrent finalize call.
-    // The meetings update is CAS-guarded on transcriptStatus='pending' (this
-    // call's own claim), and the action-items delete+insert only runs when
-    // that CAS actually matched.
+    // The meetings update is CAS-guarded on both transcriptStatus='pending'
+    // and the timestamp written by this call's claim. If a manual edit landed
+    // after the claim, finish the AI fields but preserve that edit's action
+    // items instead of replacing them with stale model output.
+    let persistedActionItems = actionItems;
     await db.transaction(async (tx) => {
+      const finalNow = new Date().toISOString();
       const written = await tx
         .update(schema.meetings)
         .set({
@@ -252,32 +256,64 @@ export default defineAction({
           summaryMd,
           bulletsJson: JSON.stringify(bullets),
           actionItemsJson: JSON.stringify(actionItems),
-          updatedAt: new Date().toISOString(),
+          updatedAt: finalNow,
         })
         .where(
           and(
             eq(schema.meetings.id, args.meetingId),
             eq(schema.meetings.transcriptStatus, "pending"),
+            eq(schema.meetings.updatedAt, claimUpdatedAt),
           ),
         )
         .returning({ id: schema.meetings.id });
-      if (!written.length) return;
+      if (written.length) {
+        // Replace the per-row action items so the dedicated table mirrors the
+        // JSON column. The meeting-row CAS above serializes this replacement
+        // with update-meeting's own meeting-row transaction.
+        await tx
+          .delete(schema.meetingActionItems)
+          .where(eq(schema.meetingActionItems.meetingId, args.meetingId));
+        if (actionItems.length) {
+          await tx.insert(schema.meetingActionItems).values(
+            actionItems.map((item) => ({
+              id: nanoid(),
+              meetingId: args.meetingId,
+              assigneeEmail: item.assigneeEmail ?? null,
+              text: item.text,
+              dueDate: item.dueDate ?? null,
+              completedAt: null,
+            })),
+          );
+        }
+        return;
+      }
 
-      // Replace the per-row action items so the dedicated table mirrors the
-      // JSON column.
-      await tx
-        .delete(schema.meetingActionItems)
-        .where(eq(schema.meetingActionItems.meetingId, args.meetingId));
-      if (actionItems.length) {
-        await tx.insert(schema.meetingActionItems).values(
-          actionItems.map((item) => ({
-            id: nanoid(),
-            meetingId: args.meetingId,
-            assigneeEmail: item.assigneeEmail ?? null,
-            text: item.text,
-            dueDate: item.dueDate ?? null,
-            completedAt: null,
-          })),
+      const [preserved] = await tx
+        .update(schema.meetings)
+        .set({
+          transcriptStatus: "ready",
+          summaryMd,
+          bulletsJson: JSON.stringify(bullets),
+          updatedAt: finalNow,
+        })
+        .where(
+          and(
+            eq(schema.meetings.id, args.meetingId),
+            eq(schema.meetings.transcriptStatus, "pending"),
+          ),
+        )
+        .returning({ actionItemsJson: schema.meetings.actionItemsJson });
+      if (!preserved?.actionItemsJson) return;
+
+      try {
+        const currentActionItems = JSON.parse(preserved.actionItemsJson);
+        if (Array.isArray(currentActionItems)) {
+          persistedActionItems = currentActionItems;
+        }
+      } catch (error) {
+        console.warn(
+          "[finalize-meeting] preserved action items JSON was malformed; keeping dedicated rows",
+          error,
         );
       }
     });
@@ -288,7 +324,7 @@ export default defineAction({
       meetingId: args.meetingId,
       summaryMd,
       bullets,
-      actionItems,
+      actionItems: persistedActionItems,
       provider: result.provider,
     };
   },

package/corpus/templates/clips/actions/get-meeting.ts

@@ -17,9 +17,11 @@ interface Bullet {
   text: string;
 }
 interface ActionItem {
-  assigneeEmail?: string;
+  id?: string;
+  assigneeEmail?: string | null;
   text: string;
-  dueDate?: string;
+  dueDate?: string | null;
+  completedAt?: string | null;
 }
 
 /**
@@ -100,10 +102,16 @@ export default defineAction({
       .from(schema.meetingParticipants)
       .where(eq(schema.meetingParticipants.meetingId, meetingId));
 
-    const actionItems = await db
+    const actionItemRows = await db
       .select()
       .from(schema.meetingActionItems)
       .where(eq(schema.meetingActionItems.meetingId, meetingId));
+    // Older meetings may have action items only in the JSON column. Prefer
+    // the dedicated rows once present, but keep those legacy meetings
+    // editable instead of returning an empty action-item list.
+    const actionItems = actionItemRows.length
+      ? actionItemRows
+      : actionItemsParsed;
 
     let recording = null;
     let transcript = null;

package/corpus/templates/clips/actions/request-transcript.ts

@@ -63,6 +63,7 @@ import {
   buildCaptionSegmentsFromText,
   normalizeTranscriptSegments,
   parseTranscriptSegments,
+  type TranscriptSegment,
 } from "../shared/transcript-segments.js";
 import { PENDING_TRANSCRIPT_HEARTBEAT_MS } from "../shared/transcript-status.js";
 import cleanupTranscript from "./cleanup-transcript.js";
@@ -498,6 +499,161 @@ function fullTextSegmentJson(
   return JSON.stringify(buildCaptionSegmentsFromText(text, durationMs));
 }
 
+type WordSegmenterConstructor = new (
+  locale?: string | string[],
+  options?: { granularity: "word" },
+) => {
+  segment: (input: string) => Iterable<{ segment: string }>;
+};
+
+function splitMeasuredText(text: string): {
+  units: string[];
+  separator: "" | " ";
+} {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return { units: [], separator: " " };
+  if (/\s/.test(text)) {
+    return {
+      units: normalized.split(" ").filter(Boolean),
+      separator: " ",
+    };
+  }
+
+  // CJK and other scripts often have no spaces between words. Segment those
+  // with the runtime's locale data when available, then fall back to Unicode
+  // code points so every timed cue can still receive some cleaned text.
+  const Segmenter = (
+    Intl as typeof Intl & { Segmenter?: WordSegmenterConstructor }
+  ).Segmenter;
+  if (Segmenter) {
+    const segmented = Array.from(
+      new Segmenter(undefined, { granularity: "word" }).segment(normalized),
+      ({ segment }) => segment,
+    );
+    if (segmented.length > 1) {
+      return { units: segmented, separator: "" };
+    }
+  }
+
+  return { units: Array.from(normalized), separator: "" };
+}
+
+function normalizeAlignmentText(text: string): string {
+  return text
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, "");
+}
+
+function hasMeasuredAttribution(segments: TranscriptSegment[]): boolean {
+  return segments.some(
+    (segment) => segment.source !== undefined || segment.speaker !== undefined,
+  );
+}
+
+/**
+ * Rewrite attributed cues only when the cleanup is a sequence-preserving
+ * normalization. Without a per-word speaker map, proportional redistribution
+ * can move words across a speaker boundary. Returning null tells the caller to
+ * keep the complete original transcript instead of storing mismatched fullText
+ * and segmentsJson.
+ */
+function rewriteAttributedSegmentText(
+  segments: TranscriptSegment[],
+  cleanedText: string,
+): TranscriptSegment[] | null {
+  const originalAlignment = normalizeAlignmentText(
+    segments.map((segment) => segment.text).join(" "),
+  );
+  const cleanedAlignment = normalizeAlignmentText(cleanedText);
+  if (!originalAlignment || originalAlignment !== cleanedAlignment) return null;
+
+  const cleanedChars = Array.from(cleanedText);
+  let charIndex = 0;
+  const rewritten: TranscriptSegment[] = [];
+
+  for (const segment of segments) {
+    const target = normalizeAlignmentText(segment.text);
+    if (!target) return null;
+    const startIndex = charIndex;
+    let normalized = "";
+
+    while (
+      charIndex < cleanedChars.length &&
+      normalized.length < target.length
+    ) {
+      normalized += normalizeAlignmentText(cleanedChars[charIndex]);
+      if (!target.startsWith(normalized)) return null;
+      charIndex += 1;
+    }
+    if (normalized !== target) return null;
+
+    // Keep punctuation and whitespace with the preceding cue. They do not
+    // affect alignment, but dropping them makes the displayed transcript look
+    // broken at every measured speaker boundary.
+    while (
+      charIndex < cleanedChars.length &&
+      !normalizeAlignmentText(cleanedChars[charIndex])
+    ) {
+      charIndex += 1;
+    }
+
+    const text = cleanedChars.slice(startIndex, charIndex).join("").trim();
+    if (!text) return null;
+    rewritten.push({ ...segment, text });
+  }
+
+  if (normalizeAlignmentText(cleanedChars.slice(charIndex).join(""))) {
+    return null;
+  }
+  return rewritten;
+}
+
+function rewriteMeasuredSegmentText(
+  segments: TranscriptSegment[],
+  cleanedText: string,
+): TranscriptSegment[] | null {
+  const cleaned = splitMeasuredText(cleanedText);
+  if (segments.length === 0 || cleaned.units.length === 0) return [];
+
+  if (hasMeasuredAttribution(segments)) {
+    return rewriteAttributedSegmentText(segments, cleanedText);
+  }
+
+  const weights = segments.map((segment) =>
+    Math.max(1, splitMeasuredText(segment.text).units.length),
+  );
+  const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+  let unitIndex = 0;
+  let weightIndex = 0;
+
+  return segments.flatMap((segment, index) => {
+    const isLast = index === segments.length - 1;
+    const remainingSegments = segments.length - index - 1;
+    const targetEnd = isLast
+      ? cleaned.units.length
+      : Math.round(
+          (cleaned.units.length * (weightIndex + weights[index])) / totalWeight,
+        );
+    // Unattributed cues can safely be dropped when cleanup removes short
+    // filler. Keep the measured timings for the remaining cues and preserve
+    // the complete cleaned text instead of reverting to stale source text.
+    const minimumEnd =
+      cleaned.units.length >= segments.length ? unitIndex + 1 : unitIndex;
+    const maximumEnd = Math.max(
+      unitIndex,
+      cleaned.units.length - remainingSegments,
+    );
+    const end = isLast
+      ? cleaned.units.length
+      : Math.min(maximumEnd, Math.max(minimumEnd, targetEnd));
+    const text = cleaned.units.slice(unitIndex, end).join(cleaned.separator);
+    unitIndex = end;
+    weightIndex += weights[index];
+    return text ? [{ ...segment, text }] : [];
+  });
+}
+
 /**
  * Pick the segments to store after cleanup rewrites the transcript text.
  *
@@ -511,9 +667,17 @@ export function resolveCleanupSegmentsJson(
   priorSegmentsJson: string | null | undefined,
   cleanedText: string,
   durationMs: number | null | undefined,
-): string {
-  if (parseTranscriptSegments(priorSegmentsJson).length > 1) {
-    return priorSegmentsJson as string;
+): string | null {
+  const priorSegments = parseTranscriptSegments(priorSegmentsJson);
+  if (priorSegments.length > 0) {
+    const rewrittenSegments = rewriteMeasuredSegmentText(
+      priorSegments,
+      cleanedText,
+    );
+    if (rewrittenSegments === null) return null;
+    if (rewrittenSegments.length > 0) {
+      return JSON.stringify(rewrittenSegments);
+    }
   }
   return fullTextSegmentJson(cleanedText, durationMs);
 }
@@ -785,6 +949,21 @@ async function cleanupNativeTranscript({
       return { cleaned: false, provider: result.provider };
     }
 
+    const cleanupSegmentsJson = resolveCleanupSegmentsJson(
+      segmentsJson,
+      cleanedText,
+      durationMs,
+    );
+    if (!cleanupSegmentsJson) {
+      await writeTranscriptCleanupState(recordingId, {
+        status: "unchanged",
+        provider: result.provider,
+        failureReason:
+          "Cleanup output could not be aligned with measured speaker cues; the original transcript was kept.",
+      });
+      return { cleaned: false, provider: result.provider };
+    }
+
     const now = new Date().toISOString();
     const language = await resolveStoredLanguage(db, recordingId);
     const updated = await db
@@ -794,11 +973,7 @@ async function cleanupNativeTranscript({
         status: "ready",
         failureReason: null,
         language,
-        segmentsJson: resolveCleanupSegmentsJson(
-          segmentsJson,
-          cleanedText,
-          durationMs,
-        ),
+        segmentsJson: cleanupSegmentsJson,
         fullText: cleanedText,
         retryCount: 0,
         updatedAt: now,

package/corpus/templates/clips/actions/update-meeting.ts

@@ -1,21 +1,27 @@
 /**
- * Update meeting content or owner/admin-managed sharing settings.
+ * Update a meeting's metadata. Editor access required.
  */
 
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { nanoid } from "../server/lib/recordings.js";
 import { booleanParam } from "./lib/cli-params.js";
 
 export default defineAction({
   description:
-    "Partially update a meeting's content. Owners and share admins can also control visibility and whether share links include the transcript.",
+    "Partially update a meeting (title, schedule, notes, summary, action items). Only provided fields are updated.",
   schema: z.object({
     id: z.string().describe("Meeting id"),
+    expectedUpdatedAt: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Reject the write if the meeting changed since it was read"),
     title: z.string().optional(),
     scheduledStart: z.string().nullish(),
     scheduledEnd: z.string().nullish(),
@@ -34,13 +40,15 @@ export default defineAction({
     actionItems: z
       .array(
         z.object({
-          assigneeEmail: z.string().email().optional(),
-          text: z.string(),
-          dueDate: z.string().optional(),
+          id: z.string().optional(),
+          assigneeEmail: z.string().email().nullable().optional(),
+          text: z.string().trim().min(1),
+          dueDate: z.string().nullable().optional(),
+          completedAt: z.string().nullable().optional(),
         }),
       )
       .optional()
-      .describe("Replace the action item set on the meetings row JSON"),
+      .describe("Replace the action item set on the meeting"),
     transcriptStatus: z.enum(["idle", "pending", "ready", "failed"]).optional(),
     shareTranscript: booleanParam
       .optional()
@@ -72,17 +80,61 @@ export default defineAction({
       patch.userNotesMd = args.userNotesMd;
     if (typeof args.summaryMd === "string") patch.summaryMd = args.summaryMd;
     if (args.bullets) patch.bulletsJson = JSON.stringify(args.bullets);
-    if (args.actionItems)
-      patch.actionItemsJson = JSON.stringify(args.actionItems);
+    const normalizedActionItems = args.actionItems?.map((item) => ({
+      id: item.id?.trim() || nanoid(),
+      assigneeEmail: item.assigneeEmail ?? null,
+      text: item.text.trim(),
+      dueDate: item.dueDate ?? null,
+      completedAt: item.completedAt ?? null,
+    }));
+    if (normalizedActionItems !== undefined)
+      patch.actionItemsJson = JSON.stringify(normalizedActionItems);
     if (args.transcriptStatus) patch.transcriptStatus = args.transcriptStatus;
     if (args.shareTranscript !== undefined)
       patch.shareTranscript = args.shareTranscript;
     if (args.visibility) patch.visibility = args.visibility;
 
-    await db
-      .update(schema.meetings)
-      .set(patch)
-      .where(eq(schema.meetings.id, args.id));
+    // Keep the denormalized JSON used by the summary and the dedicated action
+    // item rows used by list/query surfaces in sync as one mutation. In
+    // particular, completion state and manual edits must survive a refresh.
+    await db.transaction(async (tx) => {
+      const [updatedMeeting] = await tx
+        .update(schema.meetings)
+        .set(patch)
+        .where(
+          args.expectedUpdatedAt !== undefined
+            ? and(
+                eq(schema.meetings.id, args.id),
+                eq(schema.meetings.updatedAt, args.expectedUpdatedAt),
+              )
+            : eq(schema.meetings.id, args.id),
+        )
+        .returning({
+          id: schema.meetings.id,
+          updatedAt: schema.meetings.updatedAt,
+        });
+      if (!updatedMeeting) {
+        throw new Error("Meeting changed while saving. Refresh and try again.");
+      }
+
+      if (normalizedActionItems !== undefined) {
+        await tx
+          .delete(schema.meetingActionItems)
+          .where(eq(schema.meetingActionItems.meetingId, args.id));
+        if (normalizedActionItems.length > 0) {
+          await tx.insert(schema.meetingActionItems).values(
+            normalizedActionItems.map((item) => ({
+              id: item.id,
+              meetingId: args.id,
+              assigneeEmail: item.assigneeEmail,
+              text: item.text,
+              dueDate: item.dueDate,
+              completedAt: item.completedAt,
+            })),
+          );
+        }
+      }
+    });
 
     await writeAppState("refresh-signal", { ts: Date.now() });
 
@@ -92,6 +144,6 @@ export default defineAction({
       .where(eq(schema.meetings.id, args.id))
       .limit(1);
 
-    return { meeting };
+    return { meeting, actionItems: normalizedActionItems };
   },
 });