@agent-native/core 0.173.2-nightly-20260825163448 → 0.174.0

package/corpus/templates/factory/app/components/factory/FactorySettingsView.tsx

@@ -6,11 +6,21 @@ import { useT } from "@agent-native/core/client/i18n";
 import { buildSettingsRoute } from "@agent-native/core/client/navigation";
 import { SettingsGroup, SettingsRow } from "@agent-native/core/client/settings";
 import { ActionQueryError } from "@agent-native/dispatch/components";
-import { IconLoader2 } from "@tabler/icons-react";
+import { IconLoader2, IconTrash } from "@tabler/icons-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { Link } from "react-router";
 import { toast } from "sonner";
 
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Switch } from "@/components/ui/switch";
@@ -107,8 +117,12 @@ function formatAutomationDate(value: string | number | null | undefined) {
 
 export function FactorySettingsView({
   factoryId = "product-feedback",
+  factoryName,
+  onDeleted,
 }: {
   factoryId?: string;
+  factoryName: string;
+  onDeleted: () => void;
 }) {
   const t = useT();
   const [workspace, setWorkspace] = useState<"primary" | "secondary">(
@@ -128,6 +142,8 @@ export function FactorySettingsView({
     useState(true);
   const [automationFailureAlertEmail, setAutomationFailureAlertEmail] =
     useState("");
+  const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+  const [deleteConfirmation, setDeleteConfirmation] = useState("");
   const query = useActionQuery("get-triage-config", { factoryId });
   const schedulerHealthQuery = useActionQuery<FactoryAutomationHealth>(
     "get-factory-automation-health",
@@ -138,6 +154,9 @@ export function FactorySettingsView({
   const hydratedRef = useRef(false);
   const dirtyRef = useRef(false);
   const mutation = useActionMutation("save-triage-config");
+  const deleteMutation = useActionMutation("delete-factory", {
+    method: "DELETE",
+  });
 
   const applyForm = useCallback((state: TriageFormState) => {
     setWorkspace(state.workspace);
@@ -235,6 +254,24 @@ export function FactorySettingsView({
     }
   };
 
+  const deleteFactory = async () => {
+    try {
+      await deleteMutation.mutateAsync({
+        factoryId,
+        confirmName: deleteConfirmation,
+      });
+      toast.success(t("factoryRoute.factoryDeleted"));
+      setDeleteDialogOpen(false);
+      onDeleted();
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("factoryRoute.factoryDeleteFailed"),
+      );
+    }
+  };
+
   if (query.isLoading) {
     return (
       <div className="mx-auto w-full max-w-3xl space-y-6 p-4 lg:p-6">
@@ -516,6 +553,85 @@ export function FactorySettingsView({
         error={schedulerHealthQuery.error}
         t={t}
       />
+
+      {factoryId !== "product-feedback" ? (
+        <SettingsGroup title={t("factoryRoute.dangerZone")}>
+          <SettingsRow
+            label={t("factoryRoute.deleteFactory")}
+            description={t("factoryRoute.deleteFactoryDescription")}
+            control={
+              <Button
+                type="button"
+                variant="destructive"
+                onClick={() => setDeleteDialogOpen(true)}
+                disabled={deleteMutation.isPending}
+              >
+                <IconTrash />
+                {t("factoryRoute.deleteFactory")}
+              </Button>
+            }
+          />
+        </SettingsGroup>
+      ) : null}
+
+      <AlertDialog
+        open={deleteDialogOpen}
+        onOpenChange={(open) => {
+          if (deleteMutation.isPending) return;
+          setDeleteDialogOpen(open);
+          if (!open) setDeleteConfirmation("");
+        }}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>
+              {t("factoryRoute.deleteFactoryTitle", { name: factoryName })}
+            </AlertDialogTitle>
+            <AlertDialogDescription>
+              {t("factoryRoute.deleteFactoryWarning")}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <div className="grid gap-2">
+            <label
+              htmlFor="delete-factory-confirmation"
+              className="text-sm font-medium"
+            >
+              {t("factoryRoute.deleteFactoryConfirmation", {
+                name: factoryName,
+              })}
+            </label>
+            <Input
+              id="delete-factory-confirmation"
+              value={deleteConfirmation}
+              onChange={(event) => setDeleteConfirmation(event.target.value)}
+              autoComplete="off"
+              autoFocus
+            />
+          </div>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={deleteMutation.isPending}>
+              {t("factoryRoute.deleteFactoryCancel")}
+            </AlertDialogCancel>
+            <AlertDialogAction
+              className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
+              disabled={
+                deleteConfirmation !== factoryName || deleteMutation.isPending
+              }
+              onClick={(event) => {
+                event.preventDefault();
+                void deleteFactory();
+              }}
+            >
+              {deleteMutation.isPending ? (
+                <IconLoader2 className="animate-spin" />
+              ) : (
+                <IconTrash />
+              )}
+              {t("factoryRoute.deleteFactoryConfirm")}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
     </div>
   );
 }

package/corpus/templates/factory/app/i18n/en-US.ts

@@ -194,6 +194,18 @@ const messages = {
     automationsTab: "Automations",
     agentsTab: "Agents",
     factorySettings: "Settings",
+    dangerZone: "Danger Zone",
+    deleteFactory: "Delete factory",
+    deleteFactoryDescription:
+      "Permanently remove this factory, its map, queue, rules, activity, settings, polling, and automations. This action is irreversible.",
+    deleteFactoryTitle: "Delete {{name}}?",
+    deleteFactoryWarning:
+      "Work already running in GitHub, Slack, or Builder will not be cancelled.",
+    deleteFactoryConfirmation: "Type {{name}} to confirm",
+    deleteFactoryCancel: "Cancel",
+    deleteFactoryConfirm: "Delete factory",
+    factoryDeleted: "Factory deleted.",
+    factoryDeleteFailed: "Could not delete the factory.",
     agenticAppsTitle: "Agentic apps",
     agenticAppsEmpty: "No agentic apps in this workspace yet.",
     createApp: "Create app",

package/corpus/templates/factory/app/routes/factory.tsx

@@ -752,7 +752,12 @@ export default function FactoryRoute() {
         ) : activeTab === "rules" ? (
           <RulesView factoryId={factoryId} t={t} />
         ) : activeTab === "settings" ? (
-          <FactorySettingsView key={factoryId} factoryId={factoryId} />
+          <FactorySettingsView
+            key={factoryId}
+            factoryId={factoryId}
+            factoryName={graphData?.factory.name ?? graph.name}
+            onDeleted={goToFactoryList}
+          />
         ) : activeTab === "automations" ? (
           <AutomationsView key={factoryId} factoryId={factoryId} t={t} />
         ) : activeTab === "audit" ? (

package/corpus/templates/factory/changelog/2026-08-24-slack-polling-accepts-the-agentnative-bot-handle.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-24
+---
+
+Slack polling now recognizes the Agent Native bot when Slack reports its handle as @agentnative.

package/corpus/templates/factory/changelog/2026-08-24-you-can-delete-a-user-created-factory-from-settings.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-08-24
+---
+
+You can permanently delete a user-created Factory from Settings after typing its name.

package/corpus/templates/factory/server/lib/factory-automation-repair.ts

@@ -1,4 +1,8 @@
 import { getDb } from "../db/index.js";
+import {
+  DEFAULT_FACTORY_ID,
+  readFactoryDefinition,
+} from "../factory-graph/store.js";
 import {
   ensureFactoryAutomations,
   syncFactoryAutomationEnabledStates,
@@ -11,6 +15,8 @@ export async function repairFactoryAutomationsFromConfig(
   orgId: string,
   factoryId: string,
 ): Promise<void> {
+  const factory = await readFactoryDefinition(orgId, factoryId);
+  if (!factory && factoryId !== DEFAULT_FACTORY_ID) return;
   const config = await readTriageConfigRow(getDb(), orgId, factoryId);
   if (!config) return;
   const enabledNames = resolveEnabledAutomationsFromSavedConfig({

package/corpus/templates/factory/server/lib/factory-scope.ts

@@ -1,4 +1,4 @@
-import { and, eq, type AnyColumn, type SQL } from "drizzle-orm";
+import { and, eq, exists, type AnyColumn, type SQL } from "drizzle-orm";
 import { z } from "zod";
 
 import type { getDb } from "../db/index.js";
@@ -134,6 +134,50 @@ export function triageConfigUpdateRowId(
 
 type Db = ReturnType<typeof getDb>;
 
+export function factoryStillPresent(
+  db: Db,
+  orgId: string,
+  factoryId: string,
+): SQL | undefined {
+  if (factoryId === DEFAULT_FACTORY_ID) return undefined;
+  return exists(
+    db
+      .select({ id: factoryDefinitions.id })
+      .from(factoryDefinitions)
+      .where(
+        and(
+          eq(factoryDefinitions.id, factoryId),
+          eq(factoryDefinitions.orgId, orgId),
+        ),
+      ),
+  );
+}
+
+export async function requireExistingFactory(
+  db: Db,
+  orgId: string,
+  factoryId: string,
+): Promise<void> {
+  // product-feedback is virtual until first save and cannot be deleted, so a
+  // missing definition row is not a deletion fence.
+  if (factoryId === DEFAULT_FACTORY_ID) return;
+  const row = (
+    await db
+      .select({ id: factoryDefinitions.id })
+      .from(factoryDefinitions)
+      .where(
+        and(
+          eq(factoryDefinitions.id, factoryId),
+          eq(factoryDefinitions.orgId, orgId),
+        ),
+      )
+      .limit(1)
+  )[0];
+  if (!row) {
+    throw new Error("Factory not found.");
+  }
+}
+
 export async function readTriageConfigRow(
   db: Db,
   orgId: string,

package/corpus/templates/factory/server/lib/require-factory-automation.ts

@@ -1,9 +1,11 @@
 import type { ActionRunContext } from "@agent-native/core/action";
 import { listAutomationDefinitions } from "@agent-native/core/triggers";
 
+import { getDb } from "../db/index.js";
 import {
   factoryAutomationLeafName,
   readAutomationFactoryId,
+  requireExistingFactory,
 } from "./factory-scope.js";
 import type { WorkspaceMemberIdentity } from "./require-workspace-member.js";
 
@@ -79,4 +81,7 @@ export async function requireFactoryAutomation(
       "The action was not invoked by a governed Factory automation.",
     );
   }
+  if (expectedFactoryId) {
+    await requireExistingFactory(getDb(), identity.orgId, expectedFactoryId);
+  }
 }

package/corpus/templates/factory/server/triage/slack-client.ts

@@ -26,6 +26,15 @@ export interface SlackReaderIdentity {
   orgId?: string | null;
 }
 
+const AGENT_NATIVE_SLACK_USER_NAMES = new Set(["agent-native", "agentnative"]);
+
+/** Slack reports the bot as @agent-native or @agentnative; do not treat hyphen padding as the same handle. */
+export function isAgentNativeSlackUserName(value: string): boolean {
+  return AGENT_NATIVE_SLACK_USER_NAMES.has(
+    value.trim().replace(/^@/, "").toLowerCase(),
+  );
+}
+
 function createTokenResolver({
   ownerEmail,
   orgId,
@@ -53,8 +62,7 @@ export function createSlackReader(identity: SlackReaderIdentity) {
     const existing = identities.get(workspace);
     if (existing) return existing;
     const auth = await readAuthTest(workspace, tokenResolver);
-    const userName = auth.userName.trim().replace(/^@/, "").toLowerCase();
-    if (userName !== "agent-native") {
+    if (!isAgentNativeSlackUserName(auth.userName)) {
       throw new Error(
         `Slack credential authenticated as @${auth.userName}, not @agent-native.`,
       );

package/corpus/templates/plan/server/plugins/core-routes.ts

@@ -4,7 +4,12 @@ import { resolvePlanAnonymousOwner } from "../lib/public-plans.js";
 
 export default createCoreRoutesPlugin({
   anonymousOwner: resolvePlanAnonymousOwner,
-  mcpConnectServerName: "plan",
+  // Plan's published MCP server id is the bare `plan`, not the derived
+  // `agent-native-plan`: `.agents/plugins/agent-native-visual-plans/.mcp.json`
+  // ships it, and the CLI's config writers key existing client entries by it.
+  // Dropping this override would write a second entry on the next connect
+  // instead of updating the one already in a user's config.
+  mcp: { serverName: "plan" },
   envKeys: [
     { key: "DATABASE_URL", label: "Database URL", required: false },
     {

package/corpus/templates/slides/app/components/editor/SlideEditor.tsx

@@ -4541,6 +4541,7 @@ export default function SlideEditor({
         selected && !isSlideCanvasShell(selected) ? selected : null,
         clicked && !isSlideCanvasShell(clicked) ? clicked : null,
       );
+      const editableTextBlock = findSmartBlock(target, slideContent);
       const pointerIntent = resolveSlidesCanvasPointerIntent({
         hasSelectedObject: dragTarget !== null,
         targetWithinSelectedObject: dragTarget?.contains(target) ?? false,
@@ -4554,7 +4555,9 @@ export default function SlideEditor({
             e.clientX,
             e.clientY,
           ),
-        targetIsEditableText: Boolean(findSmartBlock(target, slideContent)),
+        targetIsEditableText: Boolean(
+          editableTextBlock && !isSlideCanvasShell(editableTextBlock),
+        ),
       });
       if (
         dragTarget &&

package/corpus/templates/slides/app/components/editor/canvas-interactions/slides-canvas-adapter.ts

@@ -146,8 +146,10 @@ export function resolveSlidesCanvasPointerIntent({
 }): SlidesCanvasPointerIntent {
   if (
     hasSelectedObject &&
-    (targetWithinSelectedObject || targetContainsSelectedObject) &&
-    pointerWithinMoveBand
+    pointerWithinMoveBand &&
+    (targetWithinSelectedObject ||
+      targetContainsSelectedObject ||
+      !targetIsEditableText)
   ) {
     return "move-object-perimeter";
   }

package/dist/app-config/app-identity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Fill this app's branding from the first-party template table.
+ *
+ * Runs after the schema parses, over already-resolved values — it is a pure
+ * lookup, not a layer. Reading package.json from disk here is what the earlier
+ * version did, and it put a synchronous `fs.readFileSync` inside `getAppConfig()`,
+ * which every request path calls. The repo already treats a package.json read as
+ * a development-only fallback (`server/cookie-namespace.ts` uses one solely in
+ * its non-production branch), so the input here is the declared `packageName`
+ * field and its `npm_package_name` alias.
+ *
+ * Only fills what is still unset, so an explicit `APP_NAME` or a
+ * `defineAppConfig()` value always wins.
+ *
+ * `slug` selects the per-app transactional email sender on agent-native.com, so
+ * it is only ever a name the template table already contains — an arbitrary
+ * package name cannot mint a mailbox there.
+ */
+import type { AppConfig } from "./schema.js";
+export declare function deriveAppIdentity(app: AppConfig["app"]): AppConfig["app"];

package/dist/app-config/app-identity.js

@@ -0,0 +1,41 @@
+/**
+ * Fill this app's branding from the first-party template table.
+ *
+ * Runs after the schema parses, over already-resolved values — it is a pure
+ * lookup, not a layer. Reading package.json from disk here is what the earlier
+ * version did, and it put a synchronous `fs.readFileSync` inside `getAppConfig()`,
+ * which every request path calls. The repo already treats a package.json read as
+ * a development-only fallback (`server/cookie-namespace.ts` uses one solely in
+ * its non-production branch), so the input here is the declared `packageName`
+ * field and its `npm_package_name` alias.
+ *
+ * Only fills what is still unset, so an explicit `APP_NAME` or a
+ * `defineAppConfig()` value always wins.
+ *
+ * `slug` selects the per-app transactional email sender on agent-native.com, so
+ * it is only ever a name the template table already contains — an arbitrary
+ * package name cannot mint a mailbox there.
+ */
+import { TEMPLATES } from "../cli/templates-meta.js";
+function titlecase(s) {
+    return s
+        .split(/[-_\s]+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join(" ");
+}
+export function deriveAppIdentity(app) {
+    if (app.name && app.slug && app.description)
+        return app;
+    const template = app.packageName
+        ? TEMPLATES.find((t) => t.name === app.packageName)
+        : undefined;
+    if (!template)
+        return app;
+    return {
+        ...app,
+        name: app.name ?? (template.label || titlecase(template.name)),
+        slug: app.slug ?? template.name,
+        description: app.description ?? template.hint ?? undefined,
+    };
+}

package/dist/app-config/app.d.ts

@@ -32,4 +32,6 @@ export declare const appConfig: z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
     packageName: z.ZodOptional<z.ZodString>;
     template: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/app-config/app.js

@@ -112,4 +112,18 @@ export const appConfig = z.object({
         env: ["VITE_AGENT_NATIVE_TEMPLATE"],
         doc: "First-party template this app was generated from.",
     }),
+    // ── package.json-derived branding ───────────────────────────────────────
+    //
+    // Filled by the `package` layer (the lowest one), which matches this app's
+    // package.json against the first-party template table. Deliberately no `env`
+    // alias on either: `slug` selects the per-app mailbox on agent-native.com, so
+    // it must not be settable by an ambient string on the host. The layer is the
+    // only writer, and it only ever emits a name the template table already
+    // contains.
+    slug: z.string().min(1).optional().meta({
+        doc: "First-party template slug, matched from package.json. Selects the per-app transactional email sender.",
+    }),
+    description: z.string().min(1).optional().meta({
+        doc: "One-line description of the app, from first-party template metadata.",
+    }),
 });

package/dist/app-config/observability.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * Agent trace capture.
+ *
+ * These were an `observability-config` settings row, which nothing in core ever
+ * wrote — the only "UI" was a snippet in the docs telling app authors to write
+ * it from their own code, and reading it put a database round-trip on the agent
+ * hot path inside a catch that made an outage indistinguishable from "never
+ * configured". They are deployment configuration, not a runtime preference.
+ *
+ * The three `inferredSentiment*` fields are declared here but still pass
+ * through `resolveInferredSentimentConfig`, which layers a hosted-vs-self-hosted
+ * derivation and an asymmetric "explicit false always wins" rule on top. Neither
+ * is expressible as a declared default, so that resolver stays the top layer
+ * rather than being flattened into these fields.
+ */
+export declare const observabilityConfig: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    capturePrompts: z.ZodDefault<z.ZodBoolean>;
+    captureToolArgs: z.ZodDefault<z.ZodBoolean>;
+    captureToolResults: z.ZodDefault<z.ZodBoolean>;
+    captureLlmSpans: z.ZodDefault<z.ZodBoolean>;
+    evalSampleRate: z.ZodDefault<z.ZodNumber>;
+    inferredSentimentEnabled: z.ZodOptional<z.ZodBoolean>;
+    inferredSentimentSampleRate: z.ZodOptional<z.ZodNumber>;
+    inferredSentimentModel: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;

package/dist/app-config/observability.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/**
+ * Agent trace capture.
+ *
+ * These were an `observability-config` settings row, which nothing in core ever
+ * wrote — the only "UI" was a snippet in the docs telling app authors to write
+ * it from their own code, and reading it put a database round-trip on the agent
+ * hot path inside a catch that made an outage indistinguishable from "never
+ * configured". They are deployment configuration, not a runtime preference.
+ *
+ * The three `inferredSentiment*` fields are declared here but still pass
+ * through `resolveInferredSentimentConfig`, which layers a hosted-vs-self-hosted
+ * derivation and an asymmetric "explicit false always wins" rule on top. Neither
+ * is expressible as a declared default, so that resolver stays the top layer
+ * rather than being flattened into these fields.
+ */
+export const observabilityConfig = z.object({
+    enabled: z
+        .boolean()
+        .default(true)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY"],
+        doc: "Capture agent run, model call, and tool call traces.",
+    }),
+    // Message bodies are user data, and a trace store is not a place to put them
+    // without a decision. Each of these three defaults to off for that reason.
+    capturePrompts: z
+        .boolean()
+        .default(false)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY_CAPTURE_PROMPTS"],
+        doc: "Include prompt and completion content on exported spans.",
+    }),
+    captureToolArgs: z
+        .boolean()
+        .default(false)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY_CAPTURE_TOOL_ARGS"],
+        doc: "Include action input arguments on tool spans.",
+    }),
+    captureToolResults: z
+        .boolean()
+        .default(false)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY_CAPTURE_TOOL_RESULTS"],
+        doc: "Include tool results and error text on tool spans.",
+    }),
+    captureLlmSpans: z
+        .boolean()
+        .default(true)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY_CAPTURE_LLM_SPANS"],
+        doc: "Emit one span per tool call alongside the run's trace.",
+    }),
+    evalSampleRate: z
+        .number()
+        .min(0)
+        .max(1)
+        .default(0)
+        .meta({
+        env: ["AGENT_NATIVE_OBSERVABILITY_EVAL_SAMPLE_RATE"],
+        doc: "Fraction of runs given an LLM-as-judge eval, 0 to 1.",
+    }),
+    // No env aliases: `resolveInferredSentimentConfig` owns the env step for
+    // these three, and declaring the alias here as well would give one value two
+    // resolvers — the thing this schema exists to remove.
+    inferredSentimentEnabled: z.boolean().optional().meta({
+        doc: "Classify the raw user message as positive, negative, or neutral. Defaults on for first-party hosted deployments only.",
+    }),
+    inferredSentimentSampleRate: z.number().min(0).max(1).optional().meta({
+        doc: "Deterministic fraction of eligible user messages to classify, 0 to 1.",
+    }),
+    inferredSentimentModel: z.string().min(1).default("gpt-5-6-luna").meta({
+        doc: "Model used by the managed sentiment classifier.",
+    }),
+});

package/dist/app-config/schema.d.ts

@@ -35,6 +35,8 @@ export declare const appConfigSchema: z.ZodObject<{
         url: z.ZodOptional<z.ZodString>;
         packageName: z.ZodOptional<z.ZodString>;
         template: z.ZodOptional<z.ZodString>;
+        slug: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     auth: z.ZodPrefault<z.ZodObject<{
         disableDesktopSsoFallbackInDevelopment: z.ZodDefault<z.ZodBoolean>;
@@ -48,6 +50,17 @@ export declare const appConfigSchema: z.ZodObject<{
         releaseMigrations: z.ZodDefault<z.ZodBoolean>;
         betaSchemaOwner: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    observability: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        capturePrompts: z.ZodDefault<z.ZodBoolean>;
+        captureToolArgs: z.ZodDefault<z.ZodBoolean>;
+        captureToolResults: z.ZodDefault<z.ZodBoolean>;
+        captureLlmSpans: z.ZodDefault<z.ZodBoolean>;
+        evalSampleRate: z.ZodDefault<z.ZodNumber>;
+        inferredSentimentEnabled: z.ZodOptional<z.ZodBoolean>;
+        inferredSentimentSampleRate: z.ZodOptional<z.ZodNumber>;
+        inferredSentimentModel: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
     plugins: z.ZodPrefault<z.ZodObject<{
         disabled: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             "agent-chat": "agent-chat";

package/dist/app-config/schema.js

@@ -5,6 +5,7 @@ import { appConfig } from "./app.js";
 import { authConfig } from "./auth.js";
 import { integrationsConfig } from "./integrations.js";
 import { migrationConfig } from "./migration.js";
+import { observabilityConfig } from "./observability.js";
 import { pluginsConfig } from "./plugins.js";
 import { privateBlobConfig } from "./private-blob.js";
 import { workspaceConfig } from "./workspace.js";
@@ -31,6 +32,7 @@ export const appConfigSchema = z.object({
     auth: authConfig.prefault({}),
     integrations: integrationsConfig.prefault({}),
     migration: migrationConfig.prefault({}),
+    observability: observabilityConfig.prefault({}),
     plugins: pluginsConfig.prefault({}),
     privateBlob: privateBlobConfig.prefault({}),
     workspace: workspaceConfig.prefault({}),

package/dist/app-config/store.d.ts

@@ -24,11 +24,21 @@ export declare function setAppConfigLayer(layer: AppConfigLayer, config: AppConf
 /**
  * Sets this app's server configuration.
  *
- * Call it from a server plugin. Values given here beat any environment
- * variable aliased to the same field. Calling it more than once merges, so an
- * app can split its configuration by domain across plugin files.
+ * Values given here beat any environment variable aliased to the same field.
+ * Calling it more than once merges, so an app can split its configuration by
+ * domain across plugin files.
+ *
+ * Returns a Nitro plugin so the canonical home is `server/plugins/config.ts`
+ * with `export default defineAppConfig({ … })` — the same shape as every other
+ * framework plugin an app already writes. Before that, the docs said "call it
+ * from a server plugin" without saying what such a file looks like, and no app
+ * in this repo ever did.
+ *
+ * The layer is applied here, at module load, not when the returned plugin runs:
+ * configuration has to be resolved before another plugin reads it, and plugin
+ * invocation order is not something an app should have to reason about.
  */
-export declare function defineAppConfig(config: AppConfigInput): void;
+export declare function defineAppConfig(config: AppConfigInput): () => void;
 /**
  * The resolved configuration, with declared defaults applied.
  *