@agent-native/core 0.152.1 → 0.153.0

package/corpus/templates/brain/.agents/skills/turn-into-app/references/spreadsheet-source.md

@@ -0,0 +1,148 @@
+# Spreadsheet source review
+
+Use this reference after a workbook upload or Google Sheets link is supplied to
+`/turn-into-app`. It defines the bounded review contract before app creation.
+
+## 1. Establish the source boundary
+
+Record the source before interpreting it:
+
+| Field        | Record                                                                            |
+| ------------ | --------------------------------------------------------------------------------- |
+| Source kind  | `xlsx`, `xls`, `csv`, or Google Sheets URL                                        |
+| Provenance   | Original file name or spreadsheet ID and URL; never credentials or workbook bytes |
+| Access       | Upload preview, authenticated provider read, or unavailable                       |
+| Coverage     | Worksheet names, selected range(s), row/column bounds, and sample counts          |
+| Completeness | Complete within the requested bound, partial, truncated, unreadable, or empty     |
+| Refresh      | One-time snapshot or live refreshable source                                      |
+
+For an uploaded XLS/XLSX file, the framework preview contains worksheet names,
+dimensions, and representative displayed values within bounds. It does not
+currently preserve cell fills or font colors in that text preview. Treat the
+original workbook as the formatting authority only when a tool actually returns
+cell formatting metadata. Never describe a text-only upload as style-verified.
+
+For a Google Sheets URL:
+
+1. Parse the spreadsheet ID and preserve the original URL as provenance.
+2. Use the authenticated `google_drive` provider path. Inspect
+   `provider-api-catalog` first, use `provider-api-docs` if the endpoint or
+   fields are uncertain, and then call `provider-api-request`.
+3. Read spreadsheet metadata and only bounded worksheet/range data. Request
+   formatting metadata when the I/O decision depends on colors, including
+   `userEnteredFormat.backgroundColor` and
+   `userEnteredFormat.textFormat.foregroundColor` where the provider supports
+   it. Do not use a public export URL to bypass access.
+4. Preserve the spreadsheet ID, worksheet title, A1 range, account/connection
+   choice without secrets, row limits, and refresh behavior in the brief.
+
+Keep provider responses bounded. For large sheets, stage or save the response
+and reduce it with the available dataset/code tools. A failed page, truncated
+response, or unavailable connection is not an empty sheet.
+
+## 2. Infer cells and ranges, then show the evidence
+
+Classify source material into three separate buckets. Include representative
+cell addresses or ranges and the evidence behind each classification.
+
+| Bucket             | Default signal                                                                                                     | App treatment                                                          |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- |
+| Inputs             | Yellow cell background, editable assumptions, user-entered constants, or labels such as `assumption` / `driver`    | Editable controls or bounded source parameters                         |
+| Outputs            | Blue text, formula-derived result cells, summary blocks, or labels such as `forecast` / `recommendation`           | Read-only results, charts, recommendations, exports, or review actions |
+| Static historicals | Black text used intentionally for prior-period/source records, raw rows, or labels such as `actual` / `historical` | Read-only context; never turn into editable inputs by default          |
+
+These are conventions, not permission to guess. A default black font with no
+explicit style metadata is not enough to label a range as historical. Resolve
+conflicts using labels, formulas, neighboring headers, repeated patterns, and
+the user's stated goal. If the evidence still conflicts, lower confidence and
+ask the user to confirm the proposed mapping.
+
+Keep source cells and app behavior distinct:
+
+- `Source inputs` are the workbook cells or ranges the user is expected to
+  change or refresh.
+- `Source outputs` are the workbook cells or ranges the source already derives
+  or presents.
+- `Static historicals` are context the app may filter, compare, or summarize,
+  but should not edit.
+- `App outputs` are the new app's visible results, saved records, exports,
+  alerts, or downstream handoffs. Do not invent these until the repeatable job
+  or user confirmation makes them clear.
+
+## 3. Offer candidate apps, not a tab dump
+
+Group related worksheets into candidate repeatable jobs. A candidate should
+have a recognizable user, trigger, inputs, transformation or judgment, and
+outputs. Utility tabs such as lookups, raw imports, instructions, pivots, and
+calculation helpers can support a candidate without becoming destinations.
+
+Present a compact Q&A review with multi-select options. In generated app code,
+use `askUserQuestion` from `@agent-native/core/client/agent-chat` with
+`allowMultiple: true`, stable candidate IDs as option values, and
+`allowFreeText: true` for corrections. It renders inline in the agent panel;
+do not build a custom modal. Each option should fit in a scannable row or
+choice card:
+
+```text
+Candidate: Pipeline forecast
+Uses: Assumptions, Historical Pipeline, Forecast
+Inputs: yellow assumptions in Assumptions!B4:B12 (high confidence)
+Outputs: blue forecast summary in Forecast!B3:H10 (medium confidence)
+Historical context: Historical Pipeline!A1:K500
+Question: Confirm that forecast assumptions should be editable?
+```
+
+Mark the strongest recommendation with `recommended: true`, but do not silently
+select it. Let the user select none, one, or several candidates, correct a
+proposed tab/range, or answer the unresolved question. Keep each question to
+2-4 grouped candidate jobs; for a larger workbook, group related tabs into
+jobs rather than showing a tab dump or asking a separate question for every
+worksheet. If there is only one high-confidence candidate, keep the review
+compact and ask for confirmation only when the I/O mapping or source access is
+unclear.
+
+When several candidates are selected, pass a stable candidate ID, display name,
+source worksheet/ranges, I/O mapping, confidence, and confirmation status for
+each. The generated app should expose them as separate named left-navigation
+destinations or tabs, not merge them into an opaque dashboard and not create a
+separate workspace app for every worksheet.
+
+## 4. Confirm before building or publishing
+
+The confirmation view is a source-integrity checkpoint, not a product-design
+questionnaire. Show:
+
+- the source file or spreadsheet ID and snapshot/live choice;
+- selected candidate destinations and their source tabs/ranges;
+- editable inputs, read-only outputs, and static historical context;
+- the evidence and confidence for each mapping;
+- truncation, unreadable, missing-connection, and refresh limitations;
+- the app outputs/actions that will be created.
+
+Use clear actions such as `Confirm and build`, `Edit mapping`, and `Use a
+different source`. If the host has a structured question or multi-select UI,
+use it. Otherwise, ask one concise assistant message that presents the same
+options and requires an explicit confirmation/correction before handoff.
+
+After confirmation, the online host may call
+`start-workspace-app-creation`; the Builder run itself remains autonomous and
+must record any remaining non-blocking assumptions. In a local generated app,
+persist the confirmation state in SQL/application state and keep the user on
+the review surface while the agent builds. Never claim a full import, live
+refresh, or output write until the corresponding source/action has succeeded.
+
+## 5. Failure and recovery states
+
+Keep these states distinct in the review and in the handoff:
+
+- `unreadable` - parser/provider could not read the source;
+- `partial` - only some worksheets, ranges, rows, or pages were read;
+- `truncated` - the bounded preview ended before full coverage;
+- `empty` - the requested readable range contains no values;
+- `not-connected` - authenticated Google access is required but unavailable;
+- `confirmed` - the user approved the candidate and I/O mapping.
+
+For unreadable or not-connected sources, request a CSV/XLSX export or the
+required connection. For partial or truncated sources, continue only with a
+clearly bounded snapshot or ask for a narrower range. Do not coerce any of
+these states into a successful empty source.

package/corpus/templates/brain/.agents/skills/workspace-conventions/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: workspace-conventions
+description: >-
+  Shared conventions for a multi-app Agent Native workspace: finding
+  version-matched framework docs and source, shared vs app-owned code, file and
+  blob storage, env and secrets, agent scratch files, and Dispatch Resources.
+  Use when working across workspace apps, storing files or credentials, or
+  looking up framework APIs.
+scope: dev
+---
+
+# Workspace Conventions
+
+The long-form detail behind the workspace `AGENTS.md` core rules. Read this
+before adding shared code, storing files or secrets, creating workspace
+resources, or looking up framework APIs.
+
+## Framework Docs Lookup
+
+Read `agent-native-docs` for the lookup workflow (`framework-search` first, then
+the focused `docs-search` / `source-search` readers, and the `rg` fallback).
+
+The workspace-specific slugs it does not list are `workspace` and
+`multi-app-workspace`. Feature flags and other specialized workflows are
+optional; read their skill only when the app uses them. Use package docs for framework APIs,
+the package corpus for reusable framework/template patterns, and this
+`AGENTS.md` plus `.agents/skills/` for workspace-specific conventions.
+
+Before building common workspace or agent UI, read `agent-native-toolkit` to
+inventory existing public kits and installed package seams. Read
+`customizing-agent-native` before adapting shared UI. Use the supported
+ladder: configure → compose → eject the smallest unit → propose a shared seam.
+Preview before `--apply`, commit `agent-native.ejections.json`, and never edit
+`node_modules` or eject protected runtime contracts.
+
+## Shared Conventions
+
+- All AI/LLM behavior goes through the app's agent chat. UI and server code
+  must not call model providers, AI SDK `generateText()` / `streamText()`, or
+  other inline LLM APIs directly. Use `sendToAgentChat()` for local app-agent
+  work, including hidden `context` and `submit: false` prefill/review flows.
+  Keep actions deterministic and focused. If a workflow is framed as research,
+  analysis, generation, recommendation, or synthesis, let the agent
+  orchestrate provider/data actions in the open AgentSidebar instead of hiding
+  the work in one opaque action or a separate follow-up textbox.
+  Only use `useAgentChatContext`, `setAgentChatContextItem`,
+  `listAgentChatContext`, `removeAgentChatContextItem`, and
+  `clearAgentChatContext` when UI needs two-way sync with staged context chips.
+  Read `.agents/skills/delegate-to-agent/SKILL.md` before building agent-driven
+  UI or "AI" features.
+- Put shared code in `packages/shared` only when multiple apps need it.
+- Keep app-specific screens, actions, state, and skills inside `apps/<app>`.
+- SQL is for structured records, metadata, references, and searchable text. Store
+  large files/blob payloads (base64, `data:` URLs, images, video/audio, PDFs,
+  ZIPs, screenshots, thumbnails, session replay chunks) in configured file/blob
+  storage and persist only URLs, ids, or handles.
+- Store shared runtime configuration in the workspace root `.env`; use
+  `apps/<app>/.env` only for app-specific overrides. Never hardcode API keys,
+  tokens, webhook URLs, signing secrets, private Builder/internal data, customer
+  data, or credential-looking literals in source, docs, prompts, fixtures,
+  application state, action responses, or generated app content. Use
+  secrets/OAuth/runtime configuration and obvious placeholders in examples.
+- Each app deploys its own `/*` page function, and that function ships whatever
+  the app's server bundle depends on — including a dependency only a background
+  job uses. Before an app takes on a heavy runtime (headless browser, ffmpeg,
+  media processing, ML), read `.agents/skills/performance/SKILL.md` §9 and keep
+  that work in a background function or job. A dependency belonging to one app
+  does not belong in `packages/shared`.
+- Prefer framework defaults until the workspace has a real custom rule,
+  component, plugin, action, or skill to share.
+- Keep the Workspace files view for user-authored or user-requested resources.
+  Agents may create hidden `agent_scratch` resources for temporary working
+  notes, scripts, task plans, or intermediate outputs, but should promote them
+  to normal workspace visibility only when the user explicitly asks to keep or
+  manage the file.
+- Runtime-editable global resources can be managed from Dispatch Resources.
+  Use `AGENTS.md` or `instructions/<slug>.md` for always-on guardrails,
+  `skills/<slug>/SKILL.md` for workspace skills, `context/<slug>.md` for
+  personas/positioning/messaging/company facts/brand guidelines, and
+  `agents/<slug>.md` for custom agent profiles. Scope them to All apps when
+  every workspace app should inherit them. All-app resources are inherited at
+  runtime; do not copy or sync them into individual apps.
+
+## Related Skills
+
+- **adding-workspace-apps** — Creating and mounting a new app under `apps/`.
+- **agent-native-docs** — The full docs and source-corpus lookup workflow.
+- **agent-native-toolkit** — Inventory of shared workspace and agent UI.
+- **customizing-agent-native** — The configure → compose → eject ladder.
+- **delegate-to-agent** — Routing every AI feature through the agent chat.
+- **performance** — Load cost, and (§9) cold-start artifact size per app.
+- **secrets** — Registering API keys and service credentials.
+- **storing-data** — Where structured data and large payloads belong.

package/corpus/templates/brain/AGENTS.md

@@ -77,12 +77,13 @@ Read the matching skill before deeper work:
 | `ask-brain` | Cited-answer endpoint with `federatedCoverage`. |
 | `get-knowledge` / `list-knowledge` | Read or list distilled knowledge. |
 | `get-capture` / `list-captures` | Read or list raw captures (redacted by default). |
-| `import-capture` / `import-transcript` | Ingest and queue a capture or transcript for distillation. |
+| `import-capture` / `import-transcript` / `import-markdown-files` | Ingest captures or a bounded Markdown batch and queue it for distillation. |
 | `enqueue-distillation` / `mark-capture-distilled` | Queue distillation; close the queue row. |
 | `write-knowledge` | Write/update knowledge; may return a pending proposal. |
 | `review-proposal` / `approve-proposal` / `reject-proposal` / `list-proposals` / `update-proposal` | Human review of gated writes. |
 | `set-knowledge-canonical` | Mirror approved knowledge into workspace resources. |
 | `create-source` / `update-source` / `delete-source` / `list-sources` / `get-source` | Source lifecycle. |
+| `set-resource-visibility` / `share-resource` | Set source visibility or grant explicit access. |
 | `sync-source` / `sync-due-sources` | Run one connector, or sweep all due sources. |
 | `get-brain-health` | Source health, sync freshness, queue/proposal counts. |
 | `list-connection-providers` | Provider readiness and credential health. |

package/corpus/templates/brain/actions/ask-brain.ts

@@ -173,7 +173,7 @@ function sourcePolicyEnforcement(args: {
 
 export default defineAction({
   description:
-    "Answer a company-knowledge question from published Brain knowledge, falling back to cited raw capture matches when approved knowledge is thin. Use this for every company-specific factual question instead of answering from general model knowledge. Returns a cited answer plus deep links into the Brain knowledge/capture records.",
+    "Answer a company-knowledge question from published Brain knowledge, with raw captures returned separately as clearly labeled leads when approved knowledge is thin. Use this for every company-specific factual question instead of answering from general model knowledge. Raw captures are never answer evidence. Returns a cited answer plus deep links into the Brain knowledge/capture records.",
   schema: z.object({
     question: z.string().min(1),
     mode: z.enum(["cited"]).default("cited"),
@@ -286,7 +286,9 @@ export default defineAction({
           guidance.retrieval.rawCaptureFallback === "never-answer"
             ? "I could not find enough reviewed Brain knowledge for that question yet."
             : "I could not find approved Brain knowledge or matching raw captures for that question yet.",
+        answerSource: "none",
         citations: [],
+        leadCitations: [],
         knowledge: [],
         captures: [],
         results: [],
@@ -320,14 +322,22 @@ export default defineAction({
       deepLink: captureDeepLink(item.id),
       sourcePolicy: item.answerPolicy,
     }));
+    const answerSource = knowledge.length
+      ? "approved-knowledge"
+      : eligibleCaptures.length
+        ? "unreviewed-leads"
+        : "none";
     const answerParts = [];
-    const hasCitations = knowledgeCitations.length || captureCitations.length;
+    const hasCitations = knowledgeCitations.length;
     if (guidance.retrieval.requireCitations && !hasCitations) {
       const federatedCoverage = await federatedCoveragePromise;
       return {
-        answer:
-          "I found possible Brain context, but workspace settings require citations and these results did not include usable evidence.",
+        answer: eligibleCaptures.length
+          ? "I could not find approved Brain knowledge. I found raw Brain capture leads, but they need review before they can support an answer."
+          : "I found possible Brain context, but workspace settings require citations and these results did not include usable evidence.",
+        answerSource,
         citations: [],
+        leadCitations: captureCitations,
         knowledge,
         captures: eligibleCaptures,
         results: eligibleCaptures,
@@ -344,27 +354,20 @@ export default defineAction({
           .join("\n\n"),
       );
     }
-    if (eligibleCaptures.length) {
-      const prefix = knowledge.length
-        ? "Related raw capture matches:"
-        : "I could not find approved Brain knowledge, but I found matching raw captures:";
+    if (!knowledge.length && eligibleCaptures.length) {
       answerParts.push(
-        [
-          prefix,
-          ...eligibleCaptures.map(
-            (item) =>
-              `${item.title}${item.source?.title ? ` (${item.source.title})` : ""}: ${item.snippet}`,
-          ),
-        ].join("\n\n"),
+        "I could not find approved Brain knowledge. I found matching raw Brain capture leads, but they need review before they can support an answer.",
       );
     }
 
     const federatedCoverage = await federatedCoveragePromise;
-    const citations = [...knowledgeCitations, ...captureCitations];
+    const citations = knowledgeCitations;
     const primary = citations[0] ?? null;
     return {
       answer: formatAnswer(answerParts.join("\n\n"), guidance),
+      answerSource,
       citations,
+      leadCitations: captureCitations,
       deepLink: primary?.deepLink ?? null,
       knowledge,
       captures: eligibleCaptures,

package/corpus/templates/brain/actions/create-source.ts

@@ -1,4 +1,5 @@
 import { defineAction } from "@agent-native/core";
+import { getCredentialContext } from "@agent-native/core/server";
 import { z } from "zod";
 
 import {
@@ -7,7 +8,10 @@ import {
   serializeSource,
   sha256Hex,
 } from "../server/lib/brain.js";
-import { assertSourceWorkspaceConnectionAvailable } from "../server/lib/source-credentials.js";
+import {
+  assertSourceCredentialAvailable,
+  assertSourceWorkspaceConnectionAvailable,
+} from "../server/lib/source-credentials.js";
 import { withSourceAnswerPolicy } from "../server/lib/source-policy.js";
 import {
   jsonRecordSchema,
@@ -31,7 +35,7 @@ export default defineAction({
       .string()
       .optional()
       .describe("Optional signed-ingest bearer token; stored only as a hash"),
-    visibility: z.enum(["private", "org"]).default("org"),
+    visibility: z.enum(["private", "org"]).default("private"),
     policy: sourceAnswerPolicySchema
       .optional()
       .describe(
@@ -56,6 +60,11 @@ export default defineAction({
         provider: args.provider,
         workspaceConnectionId,
       });
+      await assertSourceCredentialAvailable({
+        provider: args.provider,
+        workspaceConnectionId,
+        ctx: getCredentialContext(),
+      });
     } else {
       delete config.workspaceConnectionId;
     }

package/corpus/templates/brain/actions/import-markdown-files.ts

@@ -0,0 +1,237 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import {
+  BrainCaptureBlockedError,
+  createCapture,
+  ensureManualSource,
+  getAccessibleSource,
+  serializeSource,
+} from "../server/lib/brain.js";
+import { enqueueCaptureDistillation } from "../server/lib/distillation-queue.js";
+
+const MAX_MARKDOWN_FILES = 100;
+const MAX_MARKDOWN_FILE_CHARS = 250_000;
+const MAX_MARKDOWN_BATCH_CHARS = 4_000_000;
+
+type ImportedMarkdownResult =
+  | {
+      path: string;
+      status: "imported";
+      captureId: string;
+      distillation: "queued" | "existing" | "skipped" | "failed";
+      error?: string;
+    }
+  | {
+      path: string;
+      status: "blocked";
+      sensitivityReceipt: unknown;
+    }
+  | {
+      path: string;
+      status: "failed";
+      error: string;
+    };
+
+const markdownFileSchema = z.object({
+  path: z.string().trim().min(1).max(2_000),
+  content: z.string().max(MAX_MARKDOWN_FILE_CHARS),
+});
+
+function normalizeMarkdownPath(value: string) {
+  const rawPath = value.trim().replace(/\\/g, "/");
+  if (
+    !rawPath ||
+    rawPath.startsWith("/") ||
+    /^[A-Za-z]:\//.test(rawPath) ||
+    rawPath.includes("\0")
+  ) {
+    return { path: null, error: "The file path must be relative." };
+  }
+  const segments = rawPath.split("/").filter(Boolean);
+  if (
+    !segments.length ||
+    segments.some((segment) => segment === "." || segment === "..")
+  ) {
+    return { path: null, error: "The file path contains an invalid segment." };
+  }
+  const path = segments.join("/");
+  if (!/\.(?:md|markdown)$/i.test(path)) {
+    return { path: null, error: "Only .md and .markdown files are supported." };
+  }
+  return { path, error: null };
+}
+
+export default defineAction({
+  description:
+    "Import a bounded folder or batch of Markdown files into a manual Brain source. Paths are preserved for deduplication and each file is queued for distillation by default.",
+  schema: z.object({
+    sourceId: z.string().min(1).optional(),
+    sourceTitle: z
+      .string()
+      .trim()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe("Manual source title to create/use when sourceId is omitted"),
+    files: z.array(markdownFileSchema).min(1).max(MAX_MARKDOWN_FILES),
+    enqueueDistillation: z.coerce.boolean().default(true),
+  }),
+  run: async (args) => {
+    const prepared = args.files.map((file) => {
+      const normalized = normalizeMarkdownPath(file.path);
+      if (normalized.error) {
+        return {
+          input: file,
+          path: file.path,
+          normalizedPath: null,
+          status: "failed" as const,
+          error: normalized.error,
+        };
+      }
+      if (!file.content.trim()) {
+        return {
+          input: file,
+          path: file.path,
+          normalizedPath: normalized.path,
+          status: "failed" as const,
+          error: "The Markdown file is empty.",
+        };
+      }
+      return {
+        input: file,
+        path: file.path,
+        normalizedPath: normalized.path,
+        status: "ready" as const,
+        error: null,
+      };
+    });
+    const validFiles = prepared.filter(
+      (
+        file,
+      ): file is (typeof prepared)[number] & {
+        normalizedPath: string;
+        status: "ready";
+      } => file.status === "ready" && file.normalizedPath !== null,
+    );
+    const invalidResults = prepared
+      .filter((file) => file.status === "failed")
+      .map((file) => ({
+        path: file.path,
+        status: "failed" as const,
+        error: file.error ?? "The file could not be imported.",
+      }));
+
+    const totalCharacters = validFiles.reduce(
+      (total, file) => total + file.input.content.length,
+      0,
+    );
+    if (totalCharacters > MAX_MARKDOWN_BATCH_CHARS) {
+      throw new Error(
+        `The Markdown batch is too large. Keep the batch under ${MAX_MARKDOWN_BATCH_CHARS.toLocaleString()} characters.`,
+      );
+    }
+
+    if (!validFiles.length) {
+      return {
+        source: undefined,
+        files: invalidResults,
+        summary: {
+          requested: args.files.length,
+          imported: 0,
+          queued: 0,
+          blocked: 0,
+          failed: invalidResults.length,
+        },
+      };
+    }
+
+    const source = args.sourceId
+      ? (await getAccessibleSource(args.sourceId, "editor")).resource
+      : await ensureManualSource(args.sourceTitle ?? "Manual imports");
+    if (source.provider !== "manual") {
+      throw new Error(
+        "Markdown files can only be imported into manual sources.",
+      );
+    }
+
+    const importedResults: ImportedMarkdownResult[] = [];
+    for (const file of validFiles) {
+      const normalizedPath = file.normalizedPath;
+      try {
+        const capture = await createCapture({
+          sourceId: source.id,
+          externalId: `markdown:${normalizedPath}`,
+          title: normalizedPath,
+          kind: "document",
+          content: file.input.content,
+          metadata: {
+            path: normalizedPath,
+            sourceFormat: "markdown",
+          },
+        });
+        let distillation: "queued" | "existing" | "skipped" | "failed" =
+          "skipped";
+        let distillationError: string | undefined;
+        if (
+          args.enqueueDistillation &&
+          capture.status !== "distilled" &&
+          capture.status !== "ignored"
+        ) {
+          try {
+            const queued = await enqueueCaptureDistillation({ capture });
+            distillation = queued.existing ? "existing" : "queued";
+          } catch (error) {
+            distillation = "failed";
+            distillationError =
+              error instanceof Error ? error.message : String(error);
+          }
+        }
+        importedResults.push({
+          path: normalizedPath,
+          status: "imported",
+          captureId: capture.id,
+          distillation,
+          ...(distillationError
+            ? {
+                error: `Capture imported, but distillation failed: ${distillationError}`,
+              }
+            : {}),
+        });
+      } catch (error) {
+        if (error instanceof BrainCaptureBlockedError) {
+          importedResults.push({
+            path: normalizedPath,
+            status: "blocked",
+            sensitivityReceipt: error.receipt,
+          });
+        } else {
+          importedResults.push({
+            path: normalizedPath,
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+    }
+    const files = [...invalidResults, ...importedResults];
+    return {
+      source: serializeSource(source),
+      files,
+      summary: {
+        requested: files.length,
+        imported: importedResults.filter((file) => file.status === "imported")
+          .length,
+        queued: importedResults.filter(
+          (file) =>
+            file.status === "imported" &&
+            (file.distillation === "queued" ||
+              file.distillation === "existing"),
+        ).length,
+        blocked: importedResults.filter((file) => file.status === "blocked")
+          .length,
+        failed: files.filter((file) => file.status === "failed").length,
+      },
+    };
+  },
+});

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

@@ -25,7 +25,9 @@ function reviewPreview(value: string) {
   return redactSensitiveText(value).replace(/\s+/g, " ").trim().slice(0, 320);
 }
 
-function canEditSource(role: "viewer" | "editor" | "admin" | "owner") {
+function canEditSource(
+  role: "viewer" | "commenter" | "editor" | "admin" | "owner",
+) {
   return role === "editor" || role === "admin" || role === "owner";
 }
 

package/corpus/templates/brain/actions/test-slack-connection.ts

@@ -71,6 +71,7 @@ export default defineAction({
   }),
   run: async ({ sourceId, channelRefs, resolveNames }) => {
     let refs = channelRefs;
+    let workspaceConnectionId: string | undefined;
     if (sourceId) {
       const access = await resolveAccess("brain-source", sourceId);
       if (!access) throw new Error(`No access to brain source ${sourceId}`);
@@ -79,13 +80,21 @@ export default defineAction({
           "test-slack-connection sourceId must reference a Slack source.",
         );
       }
-      refs = refs.length
-        ? refs
-        : channelRefsFromConfig(parseJson(access.resource.configJson, {}));
+      const config = parseJson<Record<string, unknown>>(
+        access.resource.configJson,
+        {},
+      );
+      workspaceConnectionId =
+        typeof config.workspaceConnectionId === "string" &&
+        config.workspaceConnectionId.trim()
+          ? config.workspaceConnectionId.trim()
+          : undefined;
+      refs = refs.length ? refs : channelRefsFromConfig(config);
     }
     const result = await testSlackConnection({
       channelRefs: refs,
       resolveNames,
+      workspaceConnectionId,
     });
     return { ...result, sourceId: sourceId ?? null };
   },