@agent-native/core 0.93.0 → 0.94.0

package/corpus/core/src/collab/ydoc-manager.ts

@@ -181,6 +181,7 @@ async function persistMergedState(
   docId: string,
   doc: Y.Doc,
   getTextSnapshot: () => string,
+  validateTextSnapshot?: (snapshot: string) => void,
 ): Promise<void> {
   for (let attempt = 0; attempt < 5; attempt++) {
     // One DB read per persist attempt. On first attempt this is the only read
@@ -193,17 +194,21 @@ async function persistMergedState(
     }
 
     const stateToStore = buildStateToStore(doc, latest?.state?.length ?? 0);
+    const textSnapshot = getTextSnapshot();
+    validateTextSnapshot?.(textSnapshot);
     const saved = await trySaveYDocState(
       docId,
       stateToStore,
-      getTextSnapshot(),
+      textSnapshot,
       latest?.version ?? null,
     );
     if (saved) return;
   }
 
   // All CAS attempts failed — fall back to unconditional save.
-  await saveYDocState(docId, Y.encodeStateAsUpdate(doc), getTextSnapshot());
+  const textSnapshot = getTextSnapshot();
+  validateTextSnapshot?.(textSnapshot);
+  await saveYDocState(docId, Y.encodeStateAsUpdate(doc), textSnapshot);
 }
 
 /**
@@ -282,6 +287,15 @@ export async function applyText(
   newText: string,
   fieldName: string = DEFAULT_FIELD,
   requestSource?: string,
+  options: {
+    /**
+     * Validate the fully converged text after cross-process Yjs updates have
+     * merged, but before the state is persisted or broadcast. A rejected
+     * candidate is discarded from this process's cache so the next read
+     * reloads the last durable state instead of leaking an uncommitted merge.
+     */
+    validateSnapshot?: (snapshot: string) => void;
+  } = {},
 ): Promise<string> {
   return withDocWriteLock(docId, async () => {
     const doc = await getDoc(docId);
@@ -289,12 +303,33 @@ export async function applyText(
     const update = applyTextToYDoc(doc, fieldName, newText, "server");
 
     if (update.length === 0) {
-      return doc.getText(fieldName).toString();
+      const snapshot = doc.getText(fieldName).toString();
+      try {
+        options.validateSnapshot?.(snapshot);
+      } catch (error) {
+        releaseDoc(docId);
+        throw error;
+      }
+      return snapshot;
     }
 
-    await persistMergedState(docId, doc, () =>
-      doc.getText(fieldName).toString(),
-    );
+    try {
+      await persistMergedState(
+        docId,
+        doc,
+        () => doc.getText(fieldName).toString(),
+        options.validateSnapshot,
+      );
+    } catch (error) {
+      if (options.validateSnapshot) {
+        // The target diff and any cross-process state merged during the CAS
+        // read now live only in this cached Y.Doc. Destroy it before throwing:
+        // neither the rejected update nor a compensating rollback should ever
+        // be persisted/emitted to connected clients.
+        releaseDoc(docId);
+      }
+      throw error;
+    }
 
     emitCollabUpdate(docId, uint8ArrayToBase64(update), requestSource);
     touchAgentPresence(docId, requestSource, {

package/corpus/core/src/db/migrations.ts

@@ -4,10 +4,23 @@ import {
   isPostgres,
   getDialect,
   getMigrationDatabaseUrl,
+  getCloudflareD1Binding,
   retrySqliteBusy,
   type DbExec,
 } from "./client.js";
 
+interface D1PreparedStatementLike {
+  bind(...values: unknown[]): D1PreparedStatementLike;
+  all(): Promise<{ results: Record<string, unknown>[] }>;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  run(): Promise<unknown>;
+}
+
+interface D1DatabaseLike {
+  prepare(query: string): D1PreparedStatementLike;
+  batch(statements: D1PreparedStatementLike[]): Promise<unknown>;
+}
+
 // ---------------------------------------------------------------------------
 // Shared direct-endpoint exec across concurrent migration runners per boot.
 //
@@ -320,7 +333,10 @@ export function runMigrations(
   return async () => {
     try {
       // Check for Cloudflare D1 binding (only if DATABASE_URL not set)
-      const d1 = getDialect() === "d1" ? globalThis.__cf_env?.DB : null;
+      const d1 =
+        getDialect() === "d1"
+          ? (getCloudflareD1Binding() as D1DatabaseLike | undefined)
+          : null;
       if (d1) {
         await d1
           .prepare(

package/corpus/core/src/demo/fetch-interceptor.ts

@@ -47,9 +47,9 @@ const SKIP_SUBSTRINGS = [
 ];
 
 let installed = false;
-let pollTimer: ReturnType<typeof setInterval> | null = null;
 let demoEnabled = false;
 let originalFetch: typeof fetch | null = null;
+let refreshPromise: Promise<void> | null = null;
 
 // Set once the first demo-status check completes. We DO NOT block requests on
 // it — if status isn't known yet a response is simply passed through
@@ -105,8 +105,21 @@ async function refreshDemoFlag(): Promise<void> {
   }
 }
 
+/** Refresh demo mode after the shared DB-sync stream reports a real change. */
+export function refreshDemoModeFetchInterceptor(): Promise<void> {
+  if (!installed) return Promise.resolve();
+  if (!refreshPromise) {
+    refreshPromise = refreshDemoFlag().finally(() => {
+      refreshPromise = null;
+    });
+  }
+  return refreshPromise;
+}
+
 /**
- * Install the demo-mode fetch interceptor and start polling demo status.
+ * Install the demo-mode fetch interceptor and read demo status once. Later
+ * changes are driven by the shared DB-sync transport instead of a separate
+ * fixed polling loop.
  * Idempotent and browser-only — safe to call from any hook that runs in
  * every template root (we call it from `useDbSync`). A no-op until demo
  * mode is actually on.
@@ -173,13 +186,5 @@ export function ensureDemoModeFetchInterceptor(): void {
     }
   };
 
-  void refreshDemoFlag();
-  pollTimer = setInterval(() => void refreshDemoFlag(), 4_000);
-  if (typeof pollTimer === "object" && "unref" in pollTimer) {
-    try {
-      (pollTimer as unknown as { unref: () => void }).unref();
-    } catch {
-      // unref unavailable in the browser — fine, interval is cheap.
-    }
-  }
+  void refreshDemoModeFetchInterceptor();
 }

package/corpus/core/src/integrations/adapters/slack.ts

@@ -5,6 +5,7 @@ import type { EnvKeyConfig } from "../../server/create-server.js";
 import { resolveSecret } from "../../server/credential-provider.js";
 import { getRequestContext } from "../../server/request-context.js";
 import { getIntegrationRequestContext } from "../../server/request-context.js";
+import { consumeIntegrationAwaitingInput } from "../awaiting-input-store.js";
 import { createIntegrationControl } from "../controls-store.js";
 import {
   getActiveIntegrationInstallationByKey,
@@ -41,6 +42,8 @@ export interface SlackAdapterOptions {
   resolveBotToken?: (incoming: IncomingMessage) => Promise<string | undefined>;
   /** Override active-thread detection for hosted adapters/tests. */
   isThreadActive?: (incoming: IncomingMessage) => Promise<boolean>;
+  /** Override one-shot clarification-window consumption for tests. */
+  consumeAwaitingInput?: (incoming: IncomingMessage) => Promise<boolean>;
 }
 
 /**
@@ -268,10 +271,24 @@ export function slackAdapter(
         };
 
         if (isThreadReply) {
+          // An ordinary thread reply is narrowly admitted when either work is
+          // still queued or the same Slack user is answering a fresh
+          // integration-originated clarification. Consuming the latter is a
+          // conditional SQL delete, so concurrent replies cannot both reopen
+          // the agent and unrelated channel messages remain ignored.
+          const answeredClarification = options.consumeAwaitingInput
+            ? await options.consumeAwaitingInput(partialIncoming)
+            : options.isThreadActive
+              ? false
+              : await consumeIntegrationAwaitingInput({
+                  platform: "slack",
+                  externalThreadId,
+                  requesterId: e.user,
+                });
           const active = options.isThreadActive
             ? await options.isThreadActive(partialIncoming)
             : await hasActivePendingTask("slack", externalThreadId);
-          if (!active) return null;
+          if (!active && !answeredClarification) return null;
         }
 
         const token = await resolveBotToken(partialIncoming);
@@ -1295,6 +1312,7 @@ async function startSlackRunProgress(
   if (typeof streamTs !== "string") return null;
   const tasks = new Map<string, { title: string; status: string }>();
   const toolTaskIds = new Map<string, string>();
+  const agentTaskIds = new Map<string, string>();
   tasks.set("agent-native:context", {
     title: "Understand the request",
     status: "in_progress",
@@ -1443,7 +1461,9 @@ async function startSlackRunProgress(
           status: event.isError ? "error" : "complete",
         });
       } else if (event.type === "agent_call") {
-        const id = taskId("agent", event.agent);
+        const id =
+          agentTaskIds.get(event.agent) ?? taskId("agent", event.agent);
+        agentTaskIds.set(event.agent, id);
         const status =
           event.status === "start"
             ? "in_progress"
@@ -1453,6 +1473,25 @@ async function startSlackRunProgress(
         const title = `Ask ${shortTaskTitle(event.agent)}`;
         tasks.set(id, { title, status });
         await append({ type: "task_update", id, title, status });
+      } else if (event.type === "agent_call_progress") {
+        // A2A calls can stay healthy for minutes. Keep the same native Slack
+        // task card alive with each real downstream poll rather than creating
+        // a new card per tick or leaving the user with a stale spinner.
+        const id =
+          agentTaskIds.get(event.agent) ?? taskId("agent", event.agent);
+        agentTaskIds.set(event.agent, id);
+        const title = `Ask ${shortTaskTitle(event.agent)}`;
+        const details = event.detail
+          ? shortTaskTitle(event.detail)
+          : `Still ${event.state} after ${event.elapsedSeconds}s`;
+        tasks.set(id, { title, status: "in_progress" });
+        await append({
+          type: "task_update",
+          id,
+          title,
+          status: "in_progress",
+          details,
+        });
       } else if (event.type === "activity") {
         await append({
           type: "task_update",

package/corpus/core/src/integrations/awaiting-input-store.ts

@@ -0,0 +1,130 @@
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureTableExists } from "../db/ddl-guard.js";
+
+let initPromise: Promise<void> | undefined;
+
+/** Channel-thread clarification windows are deliberately short-lived. */
+export const INTEGRATION_AWAITING_INPUT_TTL_MS = 24 * 60 * 60 * 1000;
+
+async function ensureTable(): Promise<void> {
+  if (!initPromise) {
+    initPromise = (async () => {
+      const client = getDbExec();
+      const createSql = `
+        CREATE TABLE IF NOT EXISTS integration_awaiting_inputs (
+          platform TEXT NOT NULL,
+          external_thread_id TEXT NOT NULL,
+          requester_id TEXT NOT NULL,
+          expires_at ${intType()} NOT NULL,
+          created_at ${intType()} NOT NULL,
+          updated_at ${intType()} NOT NULL,
+          PRIMARY KEY (platform, external_thread_id)
+        )
+      `;
+      if (isPostgres()) {
+        await ensureTableExists("integration_awaiting_inputs", createSql);
+        return;
+      }
+      await client.execute(createSql);
+    })().catch((error) => {
+      initPromise = undefined;
+      throw error;
+    });
+  }
+  return initPromise;
+}
+
+/**
+ * Open (or refresh) the bounded reply window after an integration explicitly
+ * asks the originating Slack user a question. The workspace-qualified external
+ * thread id and requester id prevent unrelated channel messages from opting in.
+ */
+export async function setIntegrationAwaitingInput(input: {
+  platform: string;
+  externalThreadId: string;
+  requesterId: string;
+  expiresAt?: number;
+}): Promise<void> {
+  await ensureTable();
+  const requesterId = input.requesterId.trim();
+  if (!requesterId) throw new Error("requesterId is required");
+  const now = Date.now();
+  const expiresAt = input.expiresAt ?? now + INTEGRATION_AWAITING_INPUT_TTL_MS;
+  const client = getDbExec();
+  await client.execute({
+    sql: isPostgres()
+      ? `INSERT INTO integration_awaiting_inputs (platform, external_thread_id, requester_id, expires_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)
+           ON CONFLICT (platform, external_thread_id) DO UPDATE SET
+             requester_id = EXCLUDED.requester_id,
+             expires_at = EXCLUDED.expires_at,
+             updated_at = EXCLUDED.updated_at`
+      : `INSERT OR REPLACE INTO integration_awaiting_inputs (platform, external_thread_id, requester_id, expires_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [
+      input.platform,
+      input.externalThreadId,
+      requesterId,
+      expiresAt,
+      now,
+      now,
+    ],
+  });
+}
+
+/**
+ * Atomically consume the one reply window for this exact requester. Competing
+ * Slack deliveries cannot both claim it, and expired rows never authorize a
+ * later unmentioned reply.
+ */
+export async function consumeIntegrationAwaitingInput(input: {
+  platform: string;
+  externalThreadId: string;
+  requesterId: string;
+}): Promise<boolean> {
+  await ensureTable();
+  const client = getDbExec();
+  const result = await client.execute({
+    sql: isPostgres()
+      ? `DELETE FROM integration_awaiting_inputs
+           WHERE platform = ?
+             AND external_thread_id = ?
+             AND requester_id = ?
+             AND expires_at > ?
+           RETURNING platform`
+      : `DELETE FROM integration_awaiting_inputs
+           WHERE platform = ?
+             AND external_thread_id = ?
+             AND requester_id = ?
+             AND expires_at > ?`,
+    args: [
+      input.platform,
+      input.externalThreadId,
+      input.requesterId,
+      Date.now(),
+    ],
+  });
+
+  if (isPostgres()) return (result.rows ?? []).length > 0;
+  const affected =
+    (result as { rowsAffected?: number; rowCount?: number }).rowsAffected ??
+    (result as { rowsAffected?: number; rowCount?: number }).rowCount ??
+    0;
+  return affected > 0;
+}
+
+/** Clear any outstanding clarification window once the thread resolves. */
+export async function clearIntegrationAwaitingInput(
+  platform: string,
+  externalThreadId: string,
+): Promise<void> {
+  await ensureTable();
+  await getDbExec().execute({
+    sql: `DELETE FROM integration_awaiting_inputs WHERE platform = ? AND external_thread_id = ?`,
+    args: [platform, externalThreadId],
+  });
+}
+
+export function _resetIntegrationAwaitingInputStoreForTests(): void {
+  initPromise = undefined;
+}