@agent-native/core 0.111.4 → 0.113.0

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

@@ -5,7 +5,11 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { nowIso, serializeProposal } from "../server/lib/brain.js";
+import {
+  assertDerivedAudienceAccess,
+  nowIso,
+  serializeProposal,
+} from "../server/lib/brain.js";
 
 export default defineAction({
   description: "Reject a pending Brain proposal with optional reviewer notes.",
@@ -15,6 +19,7 @@ export default defineAction({
   }),
   run: async ({ proposalId, reviewerNotes }) => {
     const access = await assertAccess("brain-proposal", proposalId, "editor");
+    await assertDerivedAudienceAccess(access.resource);
     if (access.resource.status !== "pending") {
       throw new Error(
         `Proposal ${proposalId} is already ${access.resource.status}`,

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/actions/update-source.ts

@@ -11,6 +11,7 @@ import {
   stableJson,
 } from "../server/lib/brain.js";
 import { assertSourceWorkspaceConnectionAvailable } from "../server/lib/source-credentials.js";
+import { normalizeSlackChannelConfig } from "../shared/slack-source-config.js";
 import { optionalJsonRecordSchema } from "./_schemas.js";
 
 export default defineAction({
@@ -29,10 +30,13 @@ export default defineAction({
     if (args.title !== undefined) updates.title = args.title;
     if (args.status !== undefined) updates.status = args.status;
     if (args.config !== undefined) {
-      const nextConfig: Record<string, unknown> = {
+      let nextConfig: Record<string, unknown> = {
         ...parseJson<Record<string, unknown>>(existing.configJson, {}),
         ...args.config,
       };
+      if (existing.provider === "slack") {
+        nextConfig = normalizeSlackChannelConfig(nextConfig, args.config);
+      }
       const workspaceConnectionId =
         typeof nextConfig.workspaceConnectionId === "string"
           ? nextConfig.workspaceConnectionId.trim()