@agent-native/core 0.111.4 → 0.112.0

package/corpus/templates/brain/actions/resanitize-captures.ts

@@ -4,15 +4,19 @@ import { and, desc, eq, inArray, like, or } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { ensureCaptureAudience } from "../server/lib/audiences.js";
 import {
   contentHash,
   getAccessibleCapture,
+  invalidateDerivedForCapture,
   nowIso,
   parseJson,
   readBrainSettings,
+  recordBlockedCapture,
   stableJson,
 } from "../server/lib/brain.js";
 import { sanitizeCaptureForStorage } from "../server/lib/capture-sanitization.js";
+import { enqueueCaptureInvalidation } from "../server/lib/ingest-queue.js";
 import { redactSensitiveText } from "../server/lib/search.js";
 import type { BrainCaptureKind, BrainSourceProvider } from "../shared/types.js";
 import { idSchema, stringArrayCliSchema } from "./_schemas.js";
@@ -21,6 +25,10 @@ function reviewPreview(value: string) {
   return redactSensitiveText(value).replace(/\s+/g, " ").trim().slice(0, 320);
 }
 
+function canEditSource(role: "viewer" | "editor" | "admin" | "owner") {
+  return role === "editor" || role === "admin" || role === "owner";
+}
+
 async function findDerivedCitationRefs(captureId: string) {
   const db = getDb();
   const needle = `%${captureId}%`;
@@ -95,35 +103,51 @@ export default defineAction({
       const source =
         sourceAccess.resource as typeof schema.brainSources.$inferSelect;
       const captures = await db
-        .select()
+        .select({ id: schema.brainRawCaptures.id })
         .from(schema.brainRawCaptures)
         .where(
           args.includeNonTranscript
-            ? eq(schema.brainRawCaptures.sourceId, source.id)
+            ? and(
+                eq(schema.brainRawCaptures.sourceId, source.id),
+                eq(schema.brainRawCaptures.sensitivityDisposition, "allowed"),
+              )
             : and(
                 eq(schema.brainRawCaptures.sourceId, source.id),
                 eq(schema.brainRawCaptures.kind, "transcript"),
+                eq(schema.brainRawCaptures.sensitivityDisposition, "allowed"),
               ),
         )
         .orderBy(desc(schema.brainRawCaptures.capturedAt))
         .limit(args.limit);
-      for (const capture of captures) rows.push({ capture, source });
+      for (const candidate of captures) {
+        const access = await getAccessibleCapture(candidate.id);
+        if (!access) continue;
+        rows.push({ capture: access.capture, source: access.source });
+      }
     }
 
     if (args.captureIds?.length) {
       const captures = await db
-        .select()
+        .select({ id: schema.brainRawCaptures.id })
         .from(schema.brainRawCaptures)
-        .where(inArray(schema.brainRawCaptures.id, args.captureIds))
+        .where(
+          and(
+            inArray(schema.brainRawCaptures.id, args.captureIds),
+            eq(schema.brainRawCaptures.sensitivityDisposition, "allowed"),
+          ),
+        )
         .limit(args.captureIds.length);
-      for (const capture of captures) {
-        if (!args.includeNonTranscript && capture.kind !== "transcript") {
+      for (const candidate of captures) {
+        const access = await getAccessibleCapture(candidate.id);
+        if (!access || !canEditSource(access.role)) continue;
+        if (
+          !args.includeNonTranscript &&
+          access.capture.kind !== "transcript"
+        ) {
           continue;
         }
-        const access = await getAccessibleCapture(capture.id);
-        if (!access) continue;
         rows.push({
-          capture,
+          capture: access.capture,
           source: access.source,
         });
       }
@@ -139,26 +163,6 @@ export default defineAction({
       const hasDerivedRefs =
         derivedRefs.knowledgeIds.length > 0 ||
         derivedRefs.proposalIds.length > 0;
-      if (!args.dryRun && hasDerivedRefs && !args.allowCitationDrift) {
-        results.push({
-          id: row.capture.id,
-          sourceId: row.capture.sourceId,
-          externalId: row.capture.externalId,
-          title: row.capture.title,
-          capturedAt: row.capture.capturedAt,
-          beforeLength,
-          afterLength: beforeLength,
-          method: "skipped-derived-citations",
-          rawContentRetained: true,
-          skipped: true,
-          skipReason:
-            "Capture already has derived knowledge/proposals citing its current text. Run with dryRun first, then re-distill or pass allowCitationDrift=true intentionally.",
-          dependentKnowledgeIds: derivedRefs.knowledgeIds,
-          dependentProposalIds: derivedRefs.proposalIds,
-          preview: reviewPreview(row.capture.content),
-        });
-        continue;
-      }
       const sanitized = await sanitizeCaptureForStorage({
         kind: row.capture.kind as BrainCaptureKind,
         title: row.capture.title,
@@ -183,17 +187,139 @@ export default defineAction({
       const sanitizer = sanitized.metadata.captureSanitization as
         | Record<string, unknown>
         | undefined;
+      if (hasDerivedRefs && !args.allowCitationDrift) {
+        results.push({
+          id: row.capture.id,
+          sourceId: row.capture.sourceId,
+          externalId: row.capture.externalId,
+          title: sanitized.title,
+          capturedAt: row.capture.capturedAt,
+          beforeLength,
+          afterLength: sanitized.content.length,
+          method: sanitizer?.method ?? "not-sanitized",
+          rawContentRetained: sanitizer?.rawContentRetained ?? false,
+          skipped: true,
+          skipReason: "cited-derived-data",
+          dependentKnowledgeIds: derivedRefs.knowledgeIds,
+          dependentProposalIds: derivedRefs.proposalIds,
+          preview: reviewPreview(sanitized.content),
+        });
+        continue;
+      }
+      if (
+        !args.dryRun &&
+        sanitized.decision &&
+        sanitized.decision.disposition !== "allowed"
+      ) {
+        await recordBlockedCapture({
+          id: row.capture.id,
+          existing: row.capture,
+          source: row.source,
+          values: {
+            id: row.capture.id,
+            sourceId: row.capture.sourceId,
+            externalId: row.capture.externalId,
+            title: row.capture.title,
+            kind: row.capture.kind as BrainCaptureKind,
+            content: row.capture.content,
+            metadata: parseJson<Record<string, unknown>>(
+              row.capture.metadataJson,
+              {},
+            ),
+            capturedAt: row.capture.capturedAt,
+            status: row.capture.status,
+          },
+          decision: sanitized.decision,
+          retentionHours: settings.quarantineRetentionHours ?? 72,
+        });
+        results.push({
+          id: row.capture.id,
+          sourceId: row.capture.sourceId,
+          externalId: row.capture.externalId,
+          title: "Privacy-blocked capture",
+          capturedAt: row.capture.capturedAt,
+          beforeLength,
+          afterLength: 0,
+          method: sanitizer?.method ?? "deterministic",
+          rawContentRetained: false,
+          skipped: false,
+          dependentKnowledgeIds: derivedRefs.knowledgeIds,
+          dependentProposalIds: derivedRefs.proposalIds,
+          preview: "",
+        });
+        continue;
+      }
       if (!args.dryRun) {
+        const nextContentHash = await contentHash(sanitized.content);
+        let aclHash = row.capture.audienceAclHash;
+        if (!aclHash && sanitized.decision?.disposition === "allowed") {
+          aclHash = (
+            await ensureCaptureAudience({
+              captureId: row.capture.id,
+              source: row.source,
+              memberEmails:
+                row.source.visibility === "org"
+                  ? undefined
+                  : [row.source.ownerEmail],
+            })
+          ).aclHash;
+        }
         await db
           .update(schema.brainRawCaptures)
           .set({
             title: sanitized.title,
-            content: sanitized.content,
-            contentHash: await contentHash(sanitized.content),
+            content:
+              sanitized.decision?.disposition === "allowed"
+                ? sanitized.content
+                : "",
+            contentHash:
+              sanitized.decision?.disposition === "allowed"
+                ? nextContentHash
+                : await contentHash(""),
             metadataJson: stableJson(sanitized.metadata),
+            sensitivityDisposition:
+              sanitized.decision?.disposition === "allowed"
+                ? "allowed"
+                : "pending",
+            sensitivityPolicyVersion: sanitized.decision?.policyVersion ?? null,
+            audienceAclHash:
+              sanitized.decision?.disposition === "allowed" ? aclHash : null,
+            status:
+              sanitized.decision?.disposition === "allowed"
+                ? row.capture.status
+                : "ignored",
             updatedAt: nowIso(),
           })
           .where(eq(schema.brainRawCaptures.id, row.capture.id));
+        if (
+          hasDerivedRefs &&
+          (sanitized.decision?.disposition !== "allowed" ||
+            row.capture.contentHash !== nextContentHash)
+        ) {
+          await invalidateDerivedForCapture(row.capture.id);
+        }
+        await enqueueCaptureInvalidation({
+          captureId: row.capture.id,
+          sourceId: row.capture.sourceId,
+          reason:
+            sanitized.decision?.disposition === "allowed"
+              ? "content-changed"
+              : "sensitivity-changed",
+          previous: {
+            contentHash: row.capture.contentHash ?? undefined,
+            sensitivityPolicyVersion:
+              row.capture.sensitivityPolicyVersion ?? undefined,
+            aclHash: row.capture.audienceAclHash ?? undefined,
+          },
+          next:
+            sanitized.decision?.disposition === "allowed" && aclHash
+              ? {
+                  contentHash: nextContentHash,
+                  sensitivityPolicyVersion: sanitized.decision.policyVersion,
+                  aclHash,
+                }
+              : undefined,
+        });
       }
       results.push({
         id: row.capture.id,
@@ -204,7 +330,7 @@ export default defineAction({
         beforeLength,
         afterLength: sanitized.content.length,
         method: sanitizer?.method ?? "not-sanitized",
-        rawContentRetained: sanitizer?.rawContentRetained ?? true,
+        rawContentRetained: sanitizer?.rawContentRetained ?? false,
         skipped: false,
         dependentKnowledgeIds: derivedRefs.knowledgeIds,
         dependentProposalIds: derivedRefs.proposalIds,

package/corpus/templates/brain/actions/review-proposal.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
+  assertDerivedAudienceAccess,
   nowIso,
   parseJson,
   serializeProposal,
@@ -31,6 +32,7 @@ export default defineAction({
   run: async ({ id, decision, reviewerNotes, publishCanonical }) => {
     const access = await assertAccess("brain-proposal", id, "editor");
     const proposal = access.resource;
+    await assertDerivedAudienceAccess(proposal);
     if (proposal.status !== "pending") {
       throw new Error(`Proposal ${id} is already ${proposal.status}`);
     }

package/corpus/templates/brain/actions/search-everything.ts

@@ -53,6 +53,15 @@ export default defineAction({
       .enum(["manual", "generic", "clips", "slack", "granola", "github"])
       .optional()
       .describe("Restrict results to one Brain source provider."),
+    kind: z
+      .enum(["transcript", "note", "message", "document", "generic"])
+      .optional()
+      .describe("Restrict capture results to one capture kind."),
+    projectId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Restrict captures to a Brain project."),
     status: z.string().optional().describe("Restrict results to one status."),
     limit: z.coerce.number().int().min(1).max(100).default(25),
   }),
@@ -61,7 +70,7 @@ export default defineAction({
   publicAgent: {
     expose: true,
     readOnly: true,
-    requiresAuth: false,
+    requiresAuth: true,
     isConsequential: false,
   },
   run: async (args) => {

package/corpus/templates/brain/actions/search-knowledge.ts

@@ -25,7 +25,7 @@ export default defineAction({
   publicAgent: {
     expose: true,
     readOnly: true,
-    requiresAuth: false,
+    requiresAuth: true,
     isConsequential: false,
   },
   run: async (args) => {

package/corpus/templates/brain/actions/set-settings.ts

@@ -2,7 +2,30 @@ import { defineAction } from "@agent-native/core";
 import { z } from "zod";
 
 import { writeBrainSettings } from "../server/lib/brain.js";
-import { publishTierSchema } from "./_schemas.js";
+import { publishTierSchema, stringArrayCliSchema } from "./_schemas.js";
+
+function hasPrivacyWeakeningInstruction(value: string) {
+  const matches = value.matchAll(
+    /\b(?:allow|permit|release|retain|store|index|ignore|override|relax|weaken|lower|disable)\b/gi,
+  );
+  for (const match of matches) {
+    const index = match.index ?? 0;
+    const prefix = value.slice(Math.max(0, index - 32), index);
+    if (/\b(?:do not|don't|never|must not|cannot|can't)\s*$/i.test(prefix)) {
+      continue;
+    }
+    return true;
+  }
+  return false;
+}
+
+const privacyInstructionsSchema = z
+  .string()
+  .max(4_000)
+  .refine((value) => !hasPrivacyWeakeningInstruction(value), {
+    message:
+      "Privacy instructions may only add stricter exclusions; they cannot permit, retain, store, index, or release content.",
+  });
 
 export default defineAction({
   description: "Update Brain template settings.",
@@ -20,6 +43,18 @@ export default defineAction({
     captureSanitizationEnabled: z.coerce.boolean().optional(),
     captureSanitizationModel: z.string().max(160).optional(),
     captureSanitizationInstructions: z.string().max(4000).optional(),
+    privacyClassifierModel: z.string().max(160).optional(),
+    privacyClassifierEngine: z.string().max(160).optional(),
+    sensitivityCustomInstructions: privacyInstructionsSchema.optional(),
+    publicChannelExclusionPatterns: stringArrayCliSchema({ max: 100 })
+      .transform((patterns) => patterns.map((pattern) => pattern.trim()))
+      .optional(),
+    quarantineRetentionHours: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(720)
+      .optional(),
     connectorPollMinutes: z.coerce.number().int().min(5).max(1440).optional(),
     requireCitations: z.coerce.boolean().optional(),
     autoArchiveResolved: z.coerce.boolean().optional(),

package/corpus/templates/brain/actions/update-proposal.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import {
+  assertDerivedAudienceAccess,
   nowIso,
   parseJson,
   serializeProposal,
@@ -23,6 +24,7 @@ export default defineAction({
   run: async ({ proposalId, title, body, rationale }) => {
     const access = await assertAccess("brain-proposal", proposalId, "editor");
     const proposal = access.resource;
+    await assertDerivedAudienceAccess(proposal);
     if (proposal.status !== "pending") {
       throw new Error(`Proposal ${proposalId} is already ${proposal.status}`);
     }

package/corpus/templates/brain/app/hooks/use-distillation-bridge.ts

@@ -12,6 +12,7 @@ interface DistillationRequest {
   captureId?: string;
   queueId?: string;
   sourceId?: string;
+  claimToken?: string;
   requestedAt?: string;
   instructions?: string | null;
   guidance?: Record<string, unknown>;
@@ -52,15 +53,17 @@ async function clearRequest(captureId: string): Promise<void> {
 async function claimDistillation(
   captureId: string,
   queueId?: string,
-): Promise<boolean> {
+): Promise<string | null> {
   try {
     const payload = await callAction(
       "claim-distillation" as any,
       { captureId, queueId } as any,
     );
-    return Boolean(payload?.claimed);
+    return payload?.claimed && typeof payload.claimToken === "string"
+      ? payload.claimToken
+      : null;
   } catch {
-    return false;
+    return null;
   }
 }
 
@@ -121,18 +124,19 @@ export function useDistillationBridge(): void {
             request.requestedAt ?? "0"
           }`;
           if (dispatched.current.has(dispatchKey)) continue;
-          const claimed = await claimDistillation(capture.id, queueId);
-          if (!claimed) continue;
+          const claimToken = await claimDistillation(capture.id, queueId);
+          if (!claimToken || !queueId) continue;
           dispatched.current.add(dispatchKey);
 
           sendToAgentChat({
-            message: request.message ?? buildMessage(capture),
+            message: buildMessage(capture, queueId, claimToken),
             context: JSON.stringify(
               {
-                request,
+                request: { ...request, claimToken },
                 capture: summarizeCapture(capture),
                 instructions: request.instructions ?? undefined,
                 guidance: request.guidance,
+                claim: { queueId, claimToken },
               },
               null,
               2,
@@ -164,12 +168,17 @@ export function useDistillationBridge(): void {
   }, [capturesKey, dispatchableCaptures, capturesQuery.dataUpdatedAt]);
 }
 
-function buildMessage(capture: BrainCaptureReviewItem) {
+function buildMessage(
+  capture: BrainCaptureReviewItem,
+  queueId: string,
+  claimToken: string,
+) {
   return (
     `Distill Brain capture ${capture.id} (${capture.title}). ` +
     `Use get-capture with includeRawContent=true before exact quote ` +
     `validation, write durable company knowledge with write-knowledge, then ` +
-    `mark the capture distilled or ignored.`
+    `mark the capture distilled or ignored with queueId ${queueId} and ` +
+    `claimToken ${claimToken}.`
   );
 }
 

package/corpus/templates/brain/app/hooks/use-navigation-state.ts

@@ -13,6 +13,7 @@ export interface NavigationState {
   view: BrainView;
   path?: string;
   query?: string;
+  projectId?: string;
   source?: string;
   sourceType?: string;
   type?: string;
@@ -45,6 +46,7 @@ export function useNavigationState() {
         view: viewFromPath(localPathname),
         path: appPath(`${localPathname}${search}`),
         query: params.get("q") || undefined,
+        projectId: params.get("projectId") || undefined,
         source: params.get("source") || undefined,
         sourceType: params.get("type") || undefined,
         type: params.get("type") || undefined,
@@ -64,6 +66,7 @@ export function useNavigationState() {
     getCommandPath: (navCommand) => {
       const params = new URLSearchParams();
       if (navCommand.query) params.set("q", navCommand.query);
+      if (navCommand.projectId) params.set("projectId", navCommand.projectId);
       if (navCommand.source) params.set("source", navCommand.source);
       if (navCommand.type || navCommand.sourceType) {
         params.set("type", navCommand.type ?? navCommand.sourceType ?? "");