@agent-native/core 0.97.0 → 0.98.1

package/corpus/core/src/templates/workspace-core/.agents/skills/external-agents/SKILL.md

@@ -84,7 +84,8 @@ https://<your-app>.agent-native.com/_agent-native/mcp
 ```
 
 Claude / Claude Desktop: add a custom connector with the URL, click Connect,
-then sign in and approve `mcp:read`, `mcp:write`, and `mcp:apps`. Claude Code:
+then sign in and approve `mcp:read`, `mcp:write`, `mcp:apps`, and
+`offline_access`. Claude Code:
 add the same remote HTTP URL, restart if needed, run `/mcp`, and choose
 Authenticate. ChatGPT: create a custom MCP connector/app, paste the same URL,
 choose OAuth, scan/discover tools, then sign in and approve scopes. Each host

package/corpus/core/src/templates/workspace-core/.agents/skills/frontend-design/SKILL.md

@@ -48,7 +48,7 @@ Default to Apple/Linear-level restraint: make the primary workflow obvious, then
 
 - **Typography**: Use the product's existing type system first. For net-new public pages, choose characterful but readable type and keep sizing appropriate to the surface.
 - **Color and theme**: Use semantic tokens and CSS variables. Avoid one-note palettes and default purple/blue gradients unless the brand demands them.
-- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library.
+- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library. Never `transition-all` — list the properties that actually change (e.g. `transition-[opacity,transform]`). Use the shared easing tokens defined in `packages/core/src/styles/agent-native.css` instead of hand-typing curves: `var(--ease-drawer)` (260ms, drawers/app chrome), `var(--ease-collapse)` (200ms, expand/collapse), `var(--ease-out-strong)` (snappy entrances) — in Tailwind, `ease-[var(--ease-collapse)]`. Enter/exit with ease-out, never `ease-in`. Overlays that zoom in must set the Radix origin var (e.g. `origin-[--radix-popover-content-transform-origin]`). Animate `transform`/`opacity`, not width/height/padding/box-shadow. Gate looping or large-movement animations with `motion-reduce:`. Command palettes and keyboard-triggered actions get no animation.
 - **Composition**: Match the workflow. Operational apps should be dense and scannable; marketing or portfolio pages can be more immersive.
 - **Visual assets**: Websites, games, and object-focused pages need real or generated media when images help users understand the subject.
 - **Responsive fit**: Text must not overflow buttons, cards, tabs, sidebars, or fixed-format tools. Use stable dimensions for boards, grids, toolbars, and counters.

package/corpus/core/src/templates/workspace-core/.agents/skills/observability/SKILL.md

@@ -34,9 +34,41 @@ await putSetting("observability-config", {
   captureToolArgs: true,    // capture action input args
   captureToolResults: false,
   evalSampleRate: 0.05,     // 5% of runs get LLM-as-judge eval
+  inferredSentimentEnabled: false,
+  inferredSentimentSampleRate: 0,
+  inferredSentimentModel: "gpt-5-6-luna",
 });
 ```
 
+#### Optional inferred sentiment
+
+Self-hosted apps default to no inferred sentiment. First-party apps hosted on
+`agent-native.com` automatically classify 100% of eligible user replies with
+`gpt-5-6-luna`; an explicit stored `inferredSentimentEnabled: false` remains an
+opt-out. Deployment overrides are `AGENT_NATIVE_INFERRED_SENTIMENT=on|off`,
+`AGENT_NATIVE_INFERRED_SENTIMENT_SAMPLE_RATE=0..1`, and
+`AGENT_NATIVE_INFERRED_SENTIMENT_MODEL=<model>`; `off` is always the emergency
+kill switch.
+
+Classification uses only the original visible user text, capped at 2,000
+characters, with no tools, temperature 0, an eight-token output, and a five
+second timeout. It skips attachment-only turns, internal continuations, chained
+background chunks, and first turns that have no preceding response to
+attribute. The managed Builder engine runs the classifier after the main
+response has streamed, so it does not contend with the user's response.
+
+Successful classifications emit a content-free `$ai_sentiment` tracking event:
+
+- `sentiment`: `positive`, `negative`, or `neutral`
+- `method`: `llm`
+- `model` / `$ai_model`: model that generated the preceding assistant response
+- `run_id` / `$ai_trace_id`: preceding response run
+- `thread_id` / `$ai_session_id`: conversation
+- `classification_trigger_run_id`: run started by the classified user reply
+- `classifier_model` and `classifier_engine`: classifier attribution
+
+No raw message, prompt, or response text is persisted or tracked.
+
 ### 2. Feedback
 
 **Explicit** — `ThumbsFeedback` component renders inline thumbs up/down on every agent message in the chat UI. Thumbs down opens a category popover (Inaccurate, Not helpful, Wrong tool, Too slow). Already wired into `AssistantChat.tsx` via `React.lazy`.

package/corpus/core/src/templates/workspace-core/.agents/skills/real-time-sync/SKILL.md

@@ -30,7 +30,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
    useDbSync({ queryClient });
    ```
 
-   For each non-own event, `useDbSync` bumps a per-source counter (e.g. `dashboards`, `analyses`, `settings`, `action`) and invalidates a small fixed list of framework-internal prefixes (`["action"]`, `["app-state"]`, `["__set_url__"]`, etc.). It does **not** blanket-invalidate templates' own data queries for ordinary domain events — that caused a request storm in production. The exception is `source: "action"`: a successful mutating action is the framework-wide "agent changed app data" signal, so `useDbSync` also refreshes active React Query observers as a compatibility safety net for custom apps that have not yet moved every read to `useActionQuery` or source-versioned query keys.
+   For each non-own event, `useDbSync` bumps a per-source counter (e.g. `dashboards`, `analyses`, `settings`, `action`) and invalidates a small fixed list of framework-internal prefixes (`["action"]`, `["app-state"]`, `["__set_url__"]`, etc.). It does **not** blanket-invalidate templates' own data queries — that caused request storms in production. A successful mutating action refreshes active `useActionQuery` observers under the `["action"]` prefix. Browser actions carry a tab id so their originating tab ignores the sync echo while other tabs refresh. Legacy apps can opt into broader compatibility with `actionInvalidatePredicate`, but first-party apps should use action-backed or source-versioned query keys. Idle fallback polling runs once per minute; active agent work temporarily uses the faster cadence.
 
 3. **Templates fold per-source counters into their query keys.** This is the pattern that makes "agent writes show up without a manual refresh" reliable:
 
@@ -117,7 +117,7 @@ useQuery({
 | UI not updating after agent writes | Is `useDbSync` called with the correct `queryClient`? Does the affected query have an active observer?         |
 | Poll endpoint not responding       | Is `/_agent-native/poll` accessible? Is the server running?                                                    |
 | SSE not connecting                 | Is `/_agent-native/events` accessible and authenticated? Polling should still keep the UI fresh as fallback.   |
-| High CPU / event storms            | The agent is writing rapidly. Add `staleTime` to queries to debounce refetches.                                |
+| High CPU / event storms            | Use targeted source keys, settle bursty list counters, and avoid broad action invalidation.                   |
 
 ## Jitter Prevention
 

package/corpus/core/src/templates/workspace-core/.agents/skills/secrets/SKILL.md

@@ -170,9 +170,13 @@ Core routes plugin mounts these under `/_agent-native/secrets/` automatically:
 - Values are stored in `app_secrets` (created on-demand; no migration
   needed).
 - Encrypted at rest with AES-256-GCM. Key material is derived from
-  `SECRETS_ENCRYPTION_KEY` (preferred) or `BETTER_AUTH_SECRET` (fallback).
-  If neither is set, the framework uses a machine-local fallback and logs a
-  one-time warning — set `SECRETS_ENCRYPTION_KEY` in production.
+  `<APP_NAME>_SECRETS_ENCRYPTION_KEY` when set (for example,
+  `ANALYTICS_SECRETS_ENCRYPTION_KEY`), then `SECRETS_ENCRYPTION_KEY`, then
+  `BETTER_AUTH_SECRET`. App-scoped keys are useful when a local multi-app
+  workspace connects one app to its production database without replacing the
+  shared local authentication secret. If none is set, the framework uses a
+  machine-local fallback and logs a one-time warning — set stable key material
+  in production and in every runtime that reads the same encrypted data.
 
 ## Ad-hoc Keys
 

package/corpus/core/src/templates/workspace-core/.agents/skills/voice-transcription/SKILL.md

@@ -52,24 +52,54 @@ action before requesting microphone permission.
 - Starting voice mode collapses the chat into a persistent bottom-end speech
   orb. The orb stays visible above the chat even when the chat opens
   automatically. Clicking it shows or hides chat without ending the session;
-  ending the session is a separate, explicit control.
-- The orb's compact waveform must reflect actual microphone or assistant audio
-  activity. It is an audio-level indicator, not a decorative animation.
+  opening chat slides the orb clear of the sidebar. The progressively disclosed
+  controls contain only settings and the separate end-session action.
+- The orb's compact waveform stays visible for the full session and reflects
+  actual microphone or assistant audio activity. At silence it rests at its
+  baseline instead of turning into a loading spinner. While connecting, show a
+  distinct compact spinner; when the session becomes live, the assistant gives
+  one brief spoken greeting so readiness is unambiguous. Do not apply a
+  text-sized `max_output_tokens` cap to that audio greeting because audio tokens
+  can truncate it mid-sentence.
+- The orb settings cog opens in place without ending voice mode or navigating
+  away. Nested pickers must not dismiss the settings popover. Language and
+  intelligence update the active Realtime session; the microphone picker swaps
+  the live WebRTC input track and remembers the browser-local device choice;
+  an output-voice change updates immediately only before the assistant has
+  emitted audio and otherwise applies to the next conversation, matching the
+  Realtime API's voice immutability rule.
 - Semantic VAD keeps listening, starts responses automatically, and supports
   barge-in while the agent is speaking.
 - Function calls must cross the authenticated realtime tool bridge and enter
   `executeAgentToolCall`. Never call `ActionEntry.run` directly: that bypasses
   schema validation, approvals, audit/journal behavior, timeouts, redaction,
   and mutation refreshes.
-- Preserve the active browser-tab id in request context so `set-url`,
+- Preserve the active browser-tab id in request context so `set-url-path`,
   `set-search-params`, `view-screen`, and tab-scoped application state affect
-  the app the user is actually speaking to.
+  the app the user is actually speaking to. Realtime tool manifests are capped,
+  so prioritize `navigate`, `set-url-path`, `set-search-params`, and
+  `view-screen` before packing large template registries.
+- Keep `tool-search` in the initial Realtime manifest. A successful specific
+  search may expand the live session with matching action schemas, but the
+  server must derive those schemas from its own registry, bind authorization
+  to the authenticated voice session, and continue execution through
+  `executeAgentToolCall`. Treat `session.update.tools` as a full replacement:
+  preserve the pinned navigation/discovery tools, evict lower-priority entries
+  within the manifest cap, and wait for `session.updated` before asking the
+  model to continue with a newly discovered tool.
 - Do not persist audio or interim transcript deltas. Append completed user and
   assistant utterances as ordinary text messages to the exact chat thread
-  captured when the session starts. Ending voice mode opens that chat so the
-  user can continue over text. Store only compact lifecycle and latest context
-  at `application_state["realtime-voice-session"]`; delete it when the session
-  ends.
+  captured when the session starts. Input transcription completes
+  asynchronously from assistant generation, so reserve provider conversation
+  item order and publish only the contiguous completed sequence; never use
+  completion arrival time as chat order. Ending voice mode opens that chat so
+  the user can continue over text. Store only compact lifecycle and latest
+  context at `application_state["realtime-voice-session"]`; delete it when the
+  session ends.
+- Store the user-controlled language, intelligence, and output-voice choices at
+  `application_state["realtime-voice-prefs"]`. Keep this separate from
+  `voice-transcription-prefs`, which configures editable dictation rather than
+  the speech-to-speech session.
 - Missing-key failures should open Settings focused on the user-scoped
   `OPENAI_API_KEY` field. Never send, log, or echo the key to the browser.
 

package/corpus/core/src/templates/workspace-core/.agents/skills/writing-agent-instructions/SKILL.md

@@ -96,6 +96,31 @@ contract:
 - Do not create pass-through routes whose main job is to call, repackage, or
   re-export an action.
 
+## Budget the first model request
+
+Treat the initial prompt and tool catalog as a latency budget. The agent should
+start with a compact map of the app, then retrieve depth only when the task
+needs it.
+
+- Set `initialToolNames` to the small set of actions used in the app's primary
+  workflows. Keep `tool-search` available so every other registered action and
+  connected MCP tool remains discoverable on demand.
+- Keep essential, always-applicable rules in `AGENTS.md`. Put workflow detail
+  in skills and long reference material in `references/` or workspace
+  resources that the agent can read when relevant.
+- Do not inject full documents, transcripts, data dictionaries, source trees,
+  or provider catalogs through `systemPrompt` or `extraContext`. Inject a
+  bounded summary, stable ids/paths, and the exact action or resource lookup
+  that retrieves the full content.
+- Avoid duplicating action descriptions in prose. The starter tools already
+  carry schemas; uncommon actions are available through `tool-search`.
+- Keep `view-screen` concise. Return navigation, selection, visible summary,
+  and ids needed for a follow-up read rather than full record bodies.
+
+The goal is progressive disclosure, not reduced capability: a compact first
+request, precise discovery, and full fidelity once the agent knows which depth
+is relevant.
+
 When documenting version history, restore, or audit trails, use actions for
 full restorable snapshots (`list-<resource>-versions`,
 `get-<resource>-version`, `restore-<resource>-version`). Do not copy legacy

package/corpus/core/src/templates/workspace-core/src/server/index.ts

@@ -5,13 +5,15 @@ import {
   createAgentChatPlugin,
   defaultAuthPlugin,
   type AgentChatPluginOptions,
+  type NitroPluginDef,
 } from "@agent-native/core/server";
 
 export function createWorkspaceAgentChatPlugin(
   options?: AgentChatPluginOptions,
-) {
+): NitroPluginDef {
   return createAgentChatPlugin(options);
 }
 
-export const defaultAgentChatPlugin = createWorkspaceAgentChatPlugin();
+export const defaultAgentChatPlugin: NitroPluginDef =
+  createWorkspaceAgentChatPlugin();
 export { defaultAuthPlugin };

package/corpus/core/src/testing.ts

@@ -0,0 +1,26 @@
+/**
+ * `@agent-native/core/testing` — a small barrel of internal symbols that
+ * template test suites need direct access to (an in-memory db factory, the
+ * local Design/Plan dev bridges, and the shared rich-markdown-editor drag
+ * handle). Published so template specs can import these through the package
+ * boundary instead of reaching into `packages/core/src/**` with deep
+ * relative paths.
+ *
+ * Keep this list minimal — only add a re-export when a template spec
+ * actually needs it.
+ */
+
+export {
+  createGetDb,
+  patchBetterSqliteTransactions,
+} from "./db/create-get-db.js";
+
+export { startLocalPlanBridge } from "./cli/plan-local.js";
+
+export {
+  prepareDesignConnectManifest,
+  startDesignConnectBridge,
+  type DesignConnectBridge,
+} from "./cli/design-connect.js";
+
+export { DragHandle } from "./client/rich-markdown-editor/DragHandle.js";

package/corpus/core/src/triggers/dispatcher.ts

@@ -14,9 +14,11 @@ import {
 import {
   runAgentLoop,
   actionsToEngineTools,
+  filterInitialEngineTools,
   getOwnerActiveApiKey,
   type ActionEntry,
 } from "../agent/production-agent.js";
+import { attachToolSearch } from "../agent/tool-search.js";
 import type { AgentChatEvent } from "../agent/types.js";
 import { createThread } from "../chat-threads/store.js";
 import { subscribe, unsubscribe } from "../event-bus/index.js";
@@ -152,6 +154,13 @@ export function buildTriggerContent(
 export interface TriggerDispatcherDeps {
   getActions: () => Record<string, ActionEntry>;
   getSystemPrompt: (owner: string) => Promise<string>;
+  /**
+   * Tool names to expose on the FIRST engine request for a trigger run. See
+   * `SchedulerDeps.getInitialToolNames` (`jobs/scheduler.ts`) — same
+   * semantics. Omit to keep the full `getActions()` set visible up front
+   * (current behavior).
+   */
+  getInitialToolNames?: () => string[] | undefined;
   apiKey?: string;
   model?: string;
   /** App/template id used for org-scoped per-app model defaults. */
@@ -401,9 +410,20 @@ async function dispatchAgentic(
     { userEmail: jobUserEmail, orgId: jobOrgId },
     async () => {
       try {
-        const actions = _deps!.getActions();
+        const baseActions = _deps!.getActions();
         const systemPrompt = await _deps!.getSystemPrompt(jobUserEmail);
-        const tools = actionsToEngineTools(actions);
+        const initialToolNames = _deps!.getInitialToolNames?.();
+        // Only attach tool-search (and pay its schema cost) when the caller
+        // actually supplied an initial subset to filter down to — otherwise
+        // this is byte-for-byte the prior unfiltered behavior.
+        const actions = initialToolNames
+          ? attachToolSearch({ ...baseActions })
+          : baseActions;
+        const availableTools = actionsToEngineTools(actions);
+        const tools = filterInitialEngineTools(
+          availableTools,
+          initialToolNames,
+        );
 
         const engine = await resolveEngine({
           apiKey,
@@ -457,6 +477,7 @@ ${body}`;
             model,
             systemPrompt,
             tools,
+            availableTools,
             messages,
             actions,
             send: (event) => events.push(event),

package/corpus/core/src/vite/client.ts

@@ -5,7 +5,13 @@ import { createRequire, syncBuiltinESMExports } from "module";
 import path from "path";
 import { fileURLToPath } from "url";
 
-import type { ConfigEnv, Plugin, UserConfig } from "vite";
+import type {
+  ConfigEnv,
+  HotUpdateOptions,
+  NormalizedHotChannel,
+  Plugin,
+  UserConfig,
+} from "vite";
 
 import {
   mergePendingChangelog,
@@ -224,7 +230,124 @@ function nitroVitePlugin(
   ...args: Parameters<typeof import("nitro/vite").nitro>
 ) {
   installNitroFsWatchGuard();
-  return require("nitro/vite").nitro(...args);
+  const plugins = require("nitro/vite").nitro(...args) as Plugin[];
+  return plugins.map(debounceNitroFullReloadHotUpdate);
+}
+
+/**
+ * Debounce window for coalescing Nitro's dev-mode full-reload broadcasts.
+ *
+ * Nitro's own Vite plugin (the `hotUpdate` hook inside `nitro/vite`)
+ * invalidates each changed server module in the module graph synchronously,
+ * then sends `{ type: "full-reload" }` over that environment's hot channel —
+ * once per file-change event, with no debounce of its own. Every full-reload
+ * makes the Nitro dev worker re-import the entire SSR/server entry point,
+ * which is expensive. AI coding agents routinely write dozens of files in a
+ * single burst, so one edit session can trigger dozens of sequential
+ * re-imports back to back and pin a CPU core for minutes. This is a distinct
+ * concern from `fullReloadOnOptimizeDep504` elsewhere in this file (which
+ * rate-limits an unrelated client-reload nudge); keep the two independent.
+ */
+const NITRO_FULL_RELOAD_DEBOUNCE_MS = 300;
+
+/**
+ * Wraps a single Nitro-provided Vite plugin so that, if it defines a
+ * `hotUpdate` hook, any `environment.hot.send({ type: "full-reload" })` call
+ * made from inside that hook is coalesced with a trailing debounce (leading
+ * edge suppressed) instead of firing immediately for every changed file.
+ * Everything else — module-graph invalidation, non-reload hot messages, the
+ * hook's return value — passes through unchanged and immediate. A burst of
+ * N changes within the debounce window collapses into exactly one
+ * full-reload once things go quiet; a single isolated change still reloads,
+ * just delayed by up to `NITRO_FULL_RELOAD_DEBOUNCE_MS`.
+ *
+ * `hotUpdate` only ever runs on Vite's dev server (never during a build), so
+ * this has no effect outside `vite dev`.
+ */
+function debounceNitroFullReloadHotUpdate(plugin: Plugin): Plugin {
+  const originalHook = plugin.hotUpdate;
+  if (!originalHook) return plugin;
+
+  // Vite hook properties are either a plain function or `{ handler, ... }`
+  // ("object form", used to attach hook metadata like `order`). Support both.
+  const isHandlerForm = typeof originalHook === "object";
+  const originalHandler = (
+    isHandlerForm
+      ? (originalHook as { handler: unknown }).handler
+      : originalHook
+  ) as (
+    this: { environment: { name: string; hot: NormalizedHotChannel } },
+    options: HotUpdateOptions,
+  ) => unknown;
+
+  // One pending-reload timer per Vite environment name ("ssr" by default, or
+  // a named Nitro service environment), so unrelated environments can never
+  // block or coalesce into each other.
+  const pendingReloadTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+  function wrappedHotUpdate(
+    this: { environment: { name: string; hot: NormalizedHotChannel } },
+    options: HotUpdateOptions,
+  ) {
+    const realEnvironment = this.environment;
+    // Proxy `this.environment.hot.send` so nitro's hook body (which reads
+    // `this.environment` and calls `env.hot.send(...)`) is otherwise
+    // untouched — only full-reload payloads get intercepted below.
+    const proxiedThis = new Proxy(this, {
+      get(target, prop, receiver) {
+        if (prop !== "environment") {
+          return Reflect.get(target, prop, receiver);
+        }
+        return new Proxy(realEnvironment, {
+          get(envTarget, envProp, envReceiver) {
+            if (envProp !== "hot") {
+              return Reflect.get(envTarget, envProp, envReceiver);
+            }
+            const realHot = envTarget.hot;
+            return new Proxy(realHot, {
+              get(hotTarget, hotProp, hotReceiver) {
+                if (hotProp !== "send") {
+                  return Reflect.get(hotTarget, hotProp, hotReceiver);
+                }
+                return (payload: unknown) => {
+                  if (
+                    !payload ||
+                    typeof payload !== "object" ||
+                    (payload as { type?: string }).type !== "full-reload"
+                  ) {
+                    // Not a full-reload — pass through immediately.
+                    return (hotTarget.send as (p: unknown) => void)(payload);
+                  }
+                  const key = realEnvironment.name || "default";
+                  const pending = pendingReloadTimers.get(key);
+                  if (pending) clearTimeout(pending);
+                  const timer = setTimeout(() => {
+                    pendingReloadTimers.delete(key);
+                    (hotTarget.send as (p: unknown) => void)(payload);
+                  }, NITRO_FULL_RELOAD_DEBOUNCE_MS);
+                  // Never hold the process open just for a pending reload.
+                  timer.unref?.();
+                  pendingReloadTimers.set(key, timer);
+                };
+              },
+            });
+          },
+        });
+      },
+    });
+    return originalHandler.call(proxiedThis, options);
+  }
+
+  if (isHandlerForm) {
+    return {
+      ...plugin,
+      hotUpdate: {
+        ...(originalHook as object),
+        handler: wrappedHotUpdate,
+      },
+    } as Plugin;
+  }
+  return { ...plugin, hotUpdate: wrappedHotUpdate } as Plugin;
 }
 
 /**
@@ -2017,7 +2140,15 @@ function readAppChangelogMarkdown(
     .map((file) => {
       const filePath = path.join(pendingDir, file);
       watchFile(filePath);
-      return parsePendingEntry(fs.readFileSync(filePath, "utf-8"));
+      // `agent-native changelog add` prefixes every pending filename with its
+      // date. Preserve that date when a hand-written entry omits `date:` so a
+      // deployed What's new surface never groups an already-merged update
+      // under an inaccurate "Unreleased" heading.
+      const filenameDate = file.match(/^(\d{4}-\d{2}-\d{2})(?:-|\.md$)/)?.[1];
+      return parsePendingEntry(
+        fs.readFileSync(filePath, "utf-8"),
+        filenameDate,
+      );
     });
   return mergePendingChangelog(existing, pending);
 }
@@ -2797,4 +2928,5 @@ export {
   getDefaultOptimizeDeps as _getDefaultOptimizeDeps,
   findCorePackageRoot as _findCorePackageRoot,
   getReactRouterAliases as _getReactRouterAliases,
+  debounceNitroFullReloadHotUpdate as _debounceNitroFullReloadHotUpdate,
 };

package/corpus/core/tsconfig.cli.json

@@ -8,7 +8,7 @@
     "incremental": true,
     "tsBuildInfoFile": "node_modules/.cache/tsbuildinfo/core-cli.tsbuildinfo"
   },
-  "include": ["src/cli/**/*.ts"],
+  "include": ["src/cli/**/*.ts", "src/testing.ts"],
   "exclude": [
     "node_modules",
     "dist",

package/corpus/core/tsconfig.json

@@ -33,6 +33,10 @@
     // TODO: fenced concurrent-agent work — flip strict after in-flight PRs land
     // recap.ts, skills.ts, workspace-dev.ts have strict errors but are fenced.
     // Excluding all of src/cli prevents dynamic imports from re-pulling them in.
-    "src/cli/**"
+    "src/cli/**",
+    // testing.ts re-exports src/cli/** symbols (design-connect, plan-local) for
+    // the "./testing" export subpath; it compiles via tsconfig.cli.json instead
+    // so those fenced strict errors don't leak back into the main build.
+    "src/testing.ts"
   ]
 }

package/corpus/templates/analytics/.agents/skills/bigquery/SKILL.md

@@ -20,7 +20,7 @@ description: >-
 
 **Before writing any SQL, verify the metric definition and exact table/column names.**
 
-1. Check the injected `<data-dictionary>` block and call `list-data-dictionary` first.
+1. Call `list-data-dictionary` with a focused search first; dictionary definitions are loaded on demand rather than injected into every chat request.
 2. Use `search-bigquery-schema` to confirm exact dataset, table, and column names.
 3. Only write SQL after you know the correct table and columns. Do not guess.
 
@@ -33,7 +33,7 @@ writing the query is always faster than debugging a wrong result.
 
 Before writing SQL, use the highest-confidence source available:
 
-1. The injected `<data-dictionary>` block and `list-data-dictionary`.
+1. `list-data-dictionary` with a focused search or department filter.
 2. Existing dashboard SQL or saved analyses that already answer the same metric.
 3. `search-bigquery-schema` metadata for exact datasets, tables, and columns.
 4. A concise user clarification when the business meaning cannot be inferred.

package/corpus/templates/analytics/.agents/skills/frontend-design/SKILL.md

@@ -48,7 +48,7 @@ Default to Apple/Linear-level restraint: make the primary workflow obvious, then
 
 - **Typography**: Use the product's existing type system first. For net-new public pages, choose characterful but readable type and keep sizing appropriate to the surface.
 - **Color and theme**: Use semantic tokens and CSS variables. Avoid one-note palettes and default purple/blue gradients unless the brand demands them.
-- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library.
+- **Motion**: Prefer purposeful transitions and small state changes. Use CSS transitions/keyframes unless the app already uses a motion library. Never `transition-all` — list the properties that actually change (e.g. `transition-[opacity,transform]`). Use the shared easing tokens defined in `packages/core/src/styles/agent-native.css` instead of hand-typing curves: `var(--ease-drawer)` (260ms, drawers/app chrome), `var(--ease-collapse)` (200ms, expand/collapse), `var(--ease-out-strong)` (snappy entrances) — in Tailwind, `ease-[var(--ease-collapse)]`. Enter/exit with ease-out, never `ease-in`. Overlays that zoom in must set the Radix origin var (e.g. `origin-[--radix-popover-content-transform-origin]`). Animate `transform`/`opacity`, not width/height/padding/box-shadow. Gate looping or large-movement animations with `motion-reduce:`. Command palettes and keyboard-triggered actions get no animation.
 - **Composition**: Match the workflow. Operational apps should be dense and scannable; marketing or portfolio pages can be more immersive.
 - **Visual assets**: Websites, games, and object-focused pages need real or generated media when images help users understand the subject.
 - **Responsive fit**: Text must not overflow buttons, cards, tabs, sidebars, or fixed-format tools. Use stable dimensions for boards, grids, toolbars, and counters.

package/corpus/templates/analytics/.agents/skills/real-time-sync/SKILL.md

@@ -30,7 +30,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
    useDbSync({ queryClient });
    ```
 
-   For each non-own event, `useDbSync` bumps a per-source counter (e.g. `dashboards`, `analyses`, `settings`, `action`) and invalidates a small fixed list of framework-internal prefixes (`["action"]`, `["app-state"]`, `["__set_url__"]`, etc.). It does **not** blanket-invalidate templates' own data queries for ordinary domain events — that caused a request storm in production. The exception is `source: "action"`: a successful mutating action is the framework-wide "agent changed app data" signal, so `useDbSync` also refreshes active React Query observers as a compatibility safety net for custom apps that have not yet moved every read to `useActionQuery` or source-versioned query keys.
+   For each non-own event, `useDbSync` bumps a per-source counter (e.g. `dashboards`, `analyses`, `settings`, `action`) and invalidates a small fixed list of framework-internal prefixes (`["action"]`, `["app-state"]`, `["__set_url__"]`, etc.). It does **not** blanket-invalidate templates' own data queries — that caused request storms in production. A successful mutating action refreshes active `useActionQuery` observers under the `["action"]` prefix. Browser actions carry a tab id so their originating tab ignores the sync echo while other tabs refresh. Legacy apps can opt into broader compatibility with `actionInvalidatePredicate`, but first-party apps should use action-backed or source-versioned query keys. Idle fallback polling runs once per minute; active agent work temporarily uses the faster cadence.
 
 3. **Templates fold per-source counters into their query keys.** This is the pattern that makes "agent writes show up without a manual refresh" reliable:
 
@@ -117,7 +117,7 @@ useQuery({
 | UI not updating after agent writes | Is `useDbSync` called with the correct `queryClient`? Does the affected query have an active observer?         |
 | Poll endpoint not responding       | Is `/_agent-native/poll` accessible? Is the server running?                                                    |
 | SSE not connecting                 | Is `/_agent-native/events` accessible and authenticated? Polling should still keep the UI fresh as fallback.   |
-| High CPU / event storms            | The agent is writing rapidly. Add `staleTime` to queries to debounce refetches.                                |
+| High CPU / event storms            | Use targeted source keys, settle bursty list counters, and avoid broad action invalidation.                   |
 
 ## Jitter Prevention
 

package/corpus/templates/analytics/.agents/skills/session-replay/SKILL.md

@@ -28,6 +28,10 @@ agent answers about browser recordings in the Analytics template.
   `session-recording` access before reading private blob refs.
 - SQL inline chunks are a local/dev fallback only; production should use
   private or encrypted blob storage.
+- A local Analytics app pointed at a production database must also use the key
+  that encrypted those replay blobs. Set `ANALYTICS_SECRETS_ENCRYPTION_KEY` in
+  an untracked local env file; do not replace the workspace-wide
+  `BETTER_AUTH_SECRET` just to read production replay storage.
 - When sharing a replay with an external agent, use
   `create-session-replay-agent-link`. It mints a two-hour `agent_access` URL
   scoped to the recording, embeds a small SSR discovery payload on
@@ -98,11 +102,12 @@ agent answers about browser recordings in the Analytics template.
 - Wait for all replay chunks (`isComplete`) before constructing the rrweb
   `Replayer`. Progressive chunk publishes should only update the loading bar;
   rebuilding the player mid-load desyncs the scrubber and playhead.
-- Pass events to `Replayer` untouched (aside from stylesheet/script sanitization
-  that prevents blank frames from live CSS loads). Let rrweb own iframe sizing
-  via Meta / ViewportResize; use those dimensions only for CSS fit-to-stage of
-  the outer wrapper. Never rewrite Meta widths or force iframe dimensions —
-  that desyncs the FullSnapshot DOM and blanks the stage.
+- Pass events to `Replayer` untouched. rrweb rebuilds them in a sandboxed iframe;
+  pre-processing DOM, stylesheet, resource, or mutation payloads makes playback
+  diverge from the captured page. Let rrweb own iframe sizing via Meta /
+  ViewportResize, and keep the outer wrapper in that same coordinate system for
+  fit-to-stage scaling. Never clamp only one layer, rewrite Meta widths, or force
+  iframe dimensions — that desyncs the FullSnapshot DOM and breaks the stage.
 - The event timeline soft-highlights the active marker, auto-scrolls it into
   view (pausing briefly after manual scroll), and supports search. It appears
   beside the player from ~880px content width upward.

package/corpus/templates/analytics/AGENTS.md

@@ -17,9 +17,9 @@ details live in `.agents/skills/`.
 - Data integrity comes first. Do not invent numbers, dimensions, filters, or
   source semantics. State uncertainty and inspect the source when needed.
 - Catalog-first: before querying, consult known data sources (data-source
-  status) and the injected `<data-dictionary>` to learn what exists and which
-  table/columns/join paths to use. Don't fan out blind queries when the catalog
-  already answers where a fact lives.
+  status) and call `list-data-dictionary` with a focused search to learn what
+  exists and which table/columns/join paths to use. Don't fan out blind queries
+  when the catalog already answers where a fact lives.
 - Simple time-bounded metric fast path: when the data dictionary or a known
   canonical source already identifies the metric, run one bounded aggregate.
   Once that query returns a valid result, answer immediately with the source,
@@ -83,6 +83,9 @@ details live in `.agents/skills/`.
 - For shipped dashboard templates, call `list-dashboard-templates` first, then
   `install-dashboard-template` with the selected `templateId`. Do not recreate a
   catalog template by hand unless the user asks for a custom variant.
+- Agent Native observability is the exception: its panels belong in the
+  canonical Agent Native dashboard (`agent-native-templates-first-party`). Do
+  not create, publish, or install a separate observability dashboard template.
 - Agent LLM observability is collected through the same first-party tracking
   API as product analytics. Core emits PostHog-compatible `$ai_generation`
   events when emitting apps are configured with `AGENT_NATIVE_ANALYTICS_PUBLIC_KEY`
@@ -295,9 +298,15 @@ details live in `.agents/skills/`.
 - `install-dashboard-template` installs a catalog template into normal
   SQL-backed dashboards. Required: `templateId`. Optional: `dashboardId`,
   `name`, `overwrite`, `forceNew`, and `mergePanels`.
-- The LLM observability dashboard template is `agent-observability-llm`. Install
-  it when the user wants model cost, token volume, latency, error rate, or top
-  expensive agent-run visibility from first-party `$ai_generation` events.
+- Keep the canonical Agent Native dashboard
+  (`agent-native-templates-first-party`) focused: it includes one explicit
+  feedback-sentiment-by-model chart and one optional inferred-message-sentiment
+  chart, not the broader LLM cost, token, latency, or error suite. Explicit
+  feedback uses content-free `$ai_feedback` events with `sentiment` (`positive`
+  or `negative`) and model in `$ai_model` or `model`. Inferred sentiment uses
+  `$ai_sentiment` events with `method = 'llm'` and `sentiment` (`positive`,
+  `neutral`, or `negative`). Keep these panels in the canonical dashboard and
+  do not recreate a separately installable observability template.
 - To add a template's panels to an existing dashboard, call
   `install-dashboard-template` with `mergePanels: true` and the existing
   `dashboardId`. It appends only the template panels whose id is not already