@agent-native/core 0.74.0 → 0.75.1

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @agent-native/core
 
+## 0.75.1
+
+### Patch Changes
+
+- 98b89e2: Durable background agent-chat runs now actually receive Netlify's 15-min async
+  budget. The emitted `-background` function declared a custom `config.path` but
+  omitted `background: true`, so Netlify served it SYNCHRONOUSLY (~60s) — the
+  `config` object overrides the legacy `-background` filename convention — and the
+  durable worker was capped at the 60s wall (it degraded to 40s-chunked runs and
+  never used the 15-min budget). The emit now sets `background: true` (immediate
+  202 ack + 15-min execution) and force-marks the background runtime in the
+  function entry so the worker reliably takes the ~13-min soft-timeout regardless
+  of the deployed Lambda name. Root cause confirmed with a live prod routing probe
+  (POST to the process-run path returned a synchronous 401 from the handler
+  instead of a 202 async ack).
+
+## 0.75.0
+
+### Minor Changes
+
+- 1272755: Durable background agent-chat runs now complete cleanly instead of looping at
+  the 60s Netlify wall.
+  - The Netlify `-background` function (15-min async budget) is now emitted by
+    default. The deploy gates (`isDurableBackgroundDeployEnabled` in
+    `deploy/build.ts` and `deploy/workspace-deploy.ts`) are inverted to default-ON
+    to match the runtime gate — unset/empty means enabled; opt out with a falsy
+    `AGENT_CHAT_DURABLE_BACKGROUND` (`false`/`0`/`no`/`off`). This makes the chat
+    `_process-run` self-dispatch land on the real 15-min async function, so the
+    worker runs with its full budget (and likely fixes the app-specific dispatch
+    fast-fail, since the self-POST now hits an instant-202 async function).
+  - The run soft-timeout is now tied to the REAL function budget rather than
+    merely "I am the background worker." A new `isInBackgroundFunctionRuntime()`
+    guard (the Lambda function name ends in `-background`) gates the ~13-min
+    soft-timeout. A worker that lands on the regular ~60s function — or the
+    graceful inline fallback running in the foreground ~60s function — keeps the
+    ~40s soft-timeout and checkpoints before the hard wall instead of overshooting
+    and re-dispatching in a loop.
+  - Server-driven continuation stays on for every durable worker so a run survives
+    the client disconnecting (closed tab): a worker on the regular ~60s function (a
+    Netlify routing miss, or a non-Netlify host with no `-background` function)
+    self-chains 40s chunks, while a worker in a real `-background` function chains
+    ~13-min chunks. Only the per-chunk budget differs by function type; the
+    continuation is always server-driven.
+
 ## 0.74.0
 
 ### Minor Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.74.0",
+  "version": "0.75.1",
   "type": "module",
   "engines": {
     "node": ">=22"

package/corpus/core/src/agent/durable-background.ts

@@ -96,6 +96,54 @@ export function isHostedRuntimeForDurableBackground(): boolean {
   );
 }
 
+/**
+ * True when THIS process is actually executing inside a Netlify *background*
+ * function (the long, 15-min-budget async function whose deployed name ends in
+ * `-background`). Netlify runs functions on AWS Lambda and sets
+ * `AWS_LAMBDA_FUNCTION_NAME` to the function's name, so a `-background` suffix is
+ * the runtime proof that the ~60s synchronous wall does NOT apply here.
+ *
+ * This is the SAFETY GUARD for the soft-timeout regime. The `_process-run`
+ * self-dispatch worker (`isBackgroundWorker`) is NOT enough on its own: if the
+ * `-background` function was never emitted (deploy gate off, or Netlify routed
+ * the path to the synchronous function), the self-POST lands on the regular
+ * ~60s `server` function. A worker there MUST use the 40s soft-timeout and
+ * checkpoint before the 60s wall — using the ~13min budget would overshoot the
+ * hard wall and get killed at 60s, then re-dispatch/resume in a wasteful loop.
+ * So the 13-min budget is taken ONLY when this returns true.
+ *
+ * The PRIMARY signal is a `globalThis` marker the emitted background function's
+ * entry sets at cold start — the deployed Lambda name is not guaranteed to end
+ * in `-background` on Netlify, so the entry marks its own runtime. A `globalThis`
+ * flag (not `process.env`) keeps the no-env-mutation guard satisfied and carries
+ * no cross-request state (set once per isolate). The `AWS_LAMBDA_FUNCTION_NAME`
+ * suffix and the explicit `AGENT_CHAT_FORCE_BACKGROUND_RUNTIME` env (truthy) are
+ * additional signals — the latter an operator escape hatch. Off by default.
+ */
+export function isInBackgroundFunctionRuntime(): boolean {
+  // Set by the emitted `-background` function entry at cold start (the primary,
+  // most reliable signal — see the emit in deploy/build.ts).
+  if (
+    (globalThis as Record<string, unknown>)
+      .__AGENT_NATIVE_BACKGROUND_RUNTIME__ === true
+  ) {
+    return true;
+  }
+  const lambdaName = process.env.AWS_LAMBDA_FUNCTION_NAME;
+  if (
+    typeof lambdaName === "string" &&
+    lambdaName.toLowerCase().endsWith("-background")
+  ) {
+    return true;
+  }
+  const forced = process.env.AGENT_CHAT_FORCE_BACKGROUND_RUNTIME;
+  if (forced != null) {
+    const v = forced.trim().toLowerCase();
+    return v === "1" || v === "true" || v === "yes" || v === "on";
+  }
+  return false;
+}
+
 function isFlagEnabled(): boolean {
   // Read the literal key (not `process.env[CONST]`) so guard:no-env-credentials
   // can statically verify it against the allowlisted `AGENT_*` prefix. Keep this

package/corpus/core/src/agent/production-agent.ts

@@ -68,6 +68,7 @@ import {
   AGENT_CHAT_PROCESS_RUN_PATH,
   AGENT_CHAT_BACKGROUND_RUN_FIELD,
   isAgentChatDurableBackgroundEnabled,
+  isInBackgroundFunctionRuntime,
 } from "./durable-background.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { readBody } from "../server/h3-helpers.js";
@@ -3735,6 +3736,13 @@ export function createProductionAgentHandler(
         ? body[AGENT_CHAT_BACKGROUND_RUN_FIELD]!
         : null;
     const isBackgroundWorker = backgroundRunMarker !== null;
+    // Whether this worker is REALLY executing inside a 15-min Netlify
+    // `-background` function (proven by the runtime function name), not merely a
+    // `_process-run` re-entry that may have landed on the ~60s synchronous
+    // function. Only a true value unlocks the ~13-min soft-timeout budget; a
+    // worker on the 60s function keeps the 40s clamp and checkpoints cleanly.
+    const runsInBackgroundFunction =
+      isBackgroundWorker && isInBackgroundFunctionRuntime();
     // How many server-driven background continuations have already chained into
     // this logical turn (0 on the first chunk). Used to bound the chain.
     const backgroundContinuationCount =
@@ -4597,6 +4605,23 @@ export function createProductionAgentHandler(
               // user-stopped runs do NOT chain.
               if (
                 shouldChainBackgroundContinuation({
+                  // Self-chain server-side for EVERY durable worker, not only the
+                  // ones inside a `-background` function. Server-driven
+                  // continuation is the whole point of durable background: the run
+                  // must survive the client disconnecting (closed tab), so it
+                  // cannot depend on the browser re-POSTing `auto_continue`. A
+                  // worker on the regular ~60s function — a Netlify routing miss,
+                  // or a non-Netlify host (Vercel/Cloudflare/Render/Fly) that
+                  // never emits a `-background` function — checkpoints at the 40s
+                  // soft-timeout and self-dispatches the next 40s chunk; a worker
+                  // in a real `-background` function chains ~13-min chunks. Only
+                  // the per-chunk BUDGET differs by function type (gated by
+                  // `runsInBackgroundFunction` at the startRun call below); the
+                  // continuation itself must stay server-driven on both. (The
+                  // self-chain is only reachable when the initial dispatch already
+                  // succeeded — a dispatch fast-fail degrades to the inline
+                  // foreground fallback, which is not a worker and rides the
+                  // connected client's auto_continue instead.)
                   isBackgroundWorker,
                   run,
                   continuationCount: backgroundContinuationCount,
@@ -5055,10 +5080,18 @@ export function createProductionAgentHandler(
       {
         softTimeoutMs: options.runSoftTimeoutMs,
         useHostedSoftTimeoutDefault: true,
-        // Inside the Netlify background function there is no ~60s wall, so lift
-        // the soft-timeout clamp to ~13min for THIS run only. Foreground runs
-        // never set this, so their 40s clamp is unchanged.
-        backgroundFunction: isBackgroundWorker,
+        // Lift the soft-timeout clamp to ~13min ONLY when this run is actually
+        // executing inside a real Netlify `-background` function (15-min budget,
+        // no ~60s wall). Being the `_process-run` worker (`isBackgroundWorker`)
+        // is NOT sufficient: if the `-background` function wasn't emitted, or
+        // Netlify routed the self-POST to the synchronous function, the worker
+        // landed on the regular ~60s `server` function — there it MUST keep the
+        // 40s clamp and checkpoint before the wall, or it overshoots the 60s
+        // hard kill and re-dispatches in a loop. `runsInBackgroundFunction`
+        // gates the 13-min budget on the proven runtime, not merely on "I'm the
+        // worker." Foreground runs never set this, so their 40s clamp is
+        // unchanged.
+        backgroundFunction: runsInBackgroundFunction,
         // Fold continuation runs of one logical turn onto a single durable
         // assistant message. Falls back to the runId (turn == run) when the
         // client doesn't supply a turnId.

package/corpus/core/src/cli/skills.ts

@@ -394,14 +394,16 @@ sign-in at setup — this is intended), so the first tool call in that client do
 not hit an OAuth wall:
 
 \`\`\`bash
-npx @agent-native/core@latest skills add visual-plan
+npx @agent-native/core@latest skills add visual-plans
 \`\`\`
 
 After that, \`/visual-plan\` and \`/visual-recap\` are the two installed slash
-commands. The other planning modes (\`create-ui-plan\`, \`create-prototype-plan\`,
-\`create-plan-design\`, \`create-visual-questions\`) are MCP tools reachable from
-\`/visual-plan\`, not separate slash commands. Pass \`--no-connect\` to register
-the connector without authenticating, then run
+commands. If you only need one command, use \`skills add visual-plan\` or
+\`skills add visual-recap\` instead. The other planning modes
+(\`create-ui-plan\`, \`create-prototype-plan\`, \`create-plan-design\`,
+\`create-visual-questions\`) are MCP tools reachable from \`/visual-plan\`, not
+separate slash commands. Pass \`--no-connect\` to register the connector without
+authenticating, then run
 \`npx @agent-native/core@latest connect https://plan.agent-native.com --client all\`
 whenever you are ready, or choose a narrower \`--client\`. Auth and MCP tool
 loading are per client config/session.
@@ -410,7 +412,7 @@ loading are per client config/session.
 install with \`--mode local-files\`:
 
 \`\`\`bash
-npx @agent-native/core@latest skills add visual-plan --mode local-files
+npx @agent-native/core@latest skills add visual-plans --mode local-files
 \`\`\`
 
 This mode does not register the Plan MCP connector. Before authoring structured
@@ -1648,14 +1650,16 @@ sign-in at setup — this is intended), so the first tool call in that client do
 not hit an OAuth wall:
 
 \`\`\`bash
-npx @agent-native/core@latest skills add visual-plan
+npx @agent-native/core@latest skills add visual-plans
 \`\`\`
 
 After that, \`/visual-plan\` and \`/visual-recap\` are the two installed slash
-commands. The other planning modes (\`create-ui-plan\`, \`create-prototype-plan\`,
-\`create-plan-design\`, \`create-visual-questions\`) are MCP tools reachable from
-\`/visual-plan\`, not separate slash commands. Pass \`--no-connect\` to register
-the connector without authenticating, then run
+commands. If you only need one command, use \`skills add visual-plan\` or
+\`skills add visual-recap\` instead. The other planning modes
+(\`create-ui-plan\`, \`create-prototype-plan\`, \`create-plan-design\`,
+\`create-visual-questions\`) are MCP tools reachable from \`/visual-plan\`, not
+separate slash commands. Pass \`--no-connect\` to register the connector without
+authenticating, then run
 \`npx @agent-native/core@latest connect https://plan.agent-native.com --client all\`
 whenever you are ready, or choose a narrower \`--client\`. Auth and MCP tool
 loading are per client config/session.

package/corpus/core/src/deploy/build.ts

@@ -1480,14 +1480,25 @@ export function findInstalledResvgPackages(
 /**
  * Deploy-time gate for emitting the second `-background` Netlify function.
  * Reads the same env flag the runtime gate uses
- * (`AGENT_CHAT_DURABLE_BACKGROUND`). Off by default — when off, the deploy
- * emits exactly one function (today's behavior, byte-for-byte).
+ * (`AGENT_CHAT_DURABLE_BACKGROUND`).
+ *
+ * DEFAULT-ON, matching the runtime gate (`isFlagEnabled` in
+ * durable-background.ts): unset/empty/unknown means enabled; an app opts OUT
+ * only with an explicit falsy value (`false`/`0`/`no`/`off`). This is what
+ * actually emits the 15-min `-background` function so the `_process-run`
+ * dispatch lands on it (async 202 → the worker runs with the real 15-min budget
+ * → its ~13-min soft-timeout fits). The deploy gate and runtime gate MUST agree:
+ * if the deploy emitted no `-background` function but the runtime still routed
+ * the worker into the ~13-min timeout regime, the worker would overshoot the
+ * ~60s synchronous wall and re-dispatch in a loop. (The runtime now also guards
+ * the ~13-min budget on the real function name via `isInBackgroundFunctionRuntime`,
+ * so a missing emit degrades to clean 40s-chunked runs rather than the loop.)
  */
 export function isDurableBackgroundDeployEnabled(): boolean {
   const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
-  if (raw == null) return false;
+  if (raw == null) return true;
   const v = raw.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes" || v === "on";
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
 }
 
 /**
@@ -1501,15 +1512,20 @@ export function isDurableBackgroundDeployEnabled(): boolean {
  * that directory to a sibling `<...>-background` function and write an entry
  * with a `config.path` of the process-run route.
  *
- * ⚠️ REAL-DEPLOY VERIFICATION REQUIRED. Whether Netlify routes
- * `/_agent-native/agent-chat/_process-run` to this `-background` function (and
- * invokes it asynchronously with the 15-min budget) vs the synchronous Nitro
- * function cannot be verified in this environment — Nitro owns the primary
- * function's routing manifest, and the precedence between the two functions for
- * that path is a Netlify runtime behavior. If routing resolves to the
- * synchronous function, the run still completes via the existing 40s
- * soft-timeout path (no durable win, no regression). See
- * docs/design/durable-agent-runs.md (Open risks #1).
+ * The function declares `background: true` so Netlify invokes it ASYNC (HTTP
+ * 202 ack) with the 15-min budget, and a `config.path` of the process-run route
+ * so the `_process-run` self-dispatch lands on it. The earlier version set the
+ * path but omitted `background: true` and relied on the legacy `-background`
+ * filename — which the `config` object overrides — so Netlify served it
+ * SYNCHRONOUSLY (~60s) and the durable worker never got the 15-min budget
+ * (confirmed live: a POST to the process-run path returned a synchronous 401
+ * from the handler instead of a 202 async ack).
+ *
+ * ⚠️ One Netlify runtime behavior still resolves only on a real deploy: the
+ * routing precedence between this function's `config.path` and Nitro's catch-all
+ * for that exact path. If the catch-all wins, the run still completes via the
+ * 40s soft-timeout path on the sync function (no durable win, no regression).
+ * See docs/design/durable-agent-runs.md (Open risks #1).
  */
 export function emitSingleTemplateNetlifyBackgroundFunction(
   projectCwd: string,
@@ -1532,7 +1548,16 @@ export function emitSingleTemplateNetlifyBackgroundFunction(
   // Drop the original Nitro entry so our background entry is the entrypoint.
   fs.rmSync(path.join(dest, "server.mjs"), { force: true });
 
-  const entry = `let cachedHandler;
+  const entry = `// Mark this isolate as the durable background runtime BEFORE the handler
+// bundle is imported, so isInBackgroundFunctionRuntime() reliably returns true
+// in this function. The deployed Lambda name is NOT guaranteed to end in
+// "-background" (Netlify may mangle/prefix it), so we cannot depend on
+// AWS_LAMBDA_FUNCTION_NAME alone. A globalThis flag (NOT process.env) avoids the
+// no-env-mutation guard and carries no cross-request state — it is a static,
+// set-once isolate marker read back by isInBackgroundFunctionRuntime().
+globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
+
+let cachedHandler;
 
 export default async function handler(...args) {
   cachedHandler ??= (await import("./main.mjs")).default;
@@ -1542,6 +1567,15 @@ export default async function handler(...args) {
 export const config = {
   name: "agent background handler",
   generator: "agent-native build",
+  // background: true is what actually makes Netlify invoke this ASYNCHRONOUSLY
+  // (immediate HTTP 202 ack) with the 15-minute budget. Without it, a function
+  // that declares a custom \`path\` is served SYNCHRONOUSLY (~60s) even when its
+  // file name ends in "-background" — the \`config\` object overrides the legacy
+  // filename convention. That omission is why the durable worker was capped at
+  // ~60s in prod (verified live: POST to the process-run path returned a
+  // synchronous 401 from the handler, not a 202 async ack). See Netlify docs:
+  // build/functions/background-functions + build/functions/configuration.
+  background: true,
   path: ${JSON.stringify([AGENT_CHAT_PROCESS_RUN_PATH])},
   nodeBundler: "none",
   includedFiles: ["**"],
@@ -2018,11 +2052,12 @@ export default bundle;
     copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
   }
 
-  // Durable background agent runs (off by default). Additive ONLY: emits a
-  // SECOND Netlify function whose name ends in `-background` re-exporting the
-  // same handler bundle, so the chat `_process-run` POST lands on Netlify's
-  // async (15-min) function. When the flag is off this is a no-op and the
-  // single-function deploy is byte-for-byte unchanged.
+  // Durable background agent runs (default-ON; opt out with a falsy
+  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
+  // function whose name ends in `-background` re-exporting the same handler
+  // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
+  // function. When explicitly opted out this is a no-op and the single-function
+  // deploy is byte-for-byte unchanged.
   if (preset === "netlify" && isDurableBackgroundDeployEnabled()) {
     try {
       emitSingleTemplateNetlifyBackgroundFunction(cwd);

package/corpus/core/src/deploy/workspace-deploy.ts

@@ -667,8 +667,9 @@ function copyNetlifyFunctionIntoWorkspace(
   copyDir(src, dest);
   patchNetlifyFunctionEntry(dest, app, workspaceApps, staticDir);
 
-  // Durable background agent runs (off by default). Additive ONLY: when the
-  // flag is off this emits nothing and the single-function deploy is unchanged.
+  // Durable background agent runs (default-ON; opt out with a falsy
+  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: when explicitly opted out
+  // this emits nothing and the single-function deploy is unchanged.
   if (isDurableBackgroundDeployEnabled()) {
     emitNetlifyBackgroundFunction(workspaceRoot, app, src, workspaceApps);
   }
@@ -677,14 +678,19 @@ function copyNetlifyFunctionIntoWorkspace(
 /**
  * Deploy-time gate for emitting the second `-background` Netlify function. Reads
  * the same env flag the runtime gate uses (`AGENT_CHAT_DURABLE_BACKGROUND`).
- * Off by default — when off, the deploy emits exactly one function per app
- * (today's behavior, byte-for-byte).
+ *
+ * DEFAULT-ON, matching the runtime gate (`isFlagEnabled` in
+ * durable-background.ts) and the single-template gate
+ * (`isDurableBackgroundDeployEnabled` in deploy/build.ts): unset/empty/unknown
+ * means enabled; an app opts OUT only with an explicit falsy value
+ * (`false`/`0`/`no`/`off`). This emits the per-app 15-min `-background` function
+ * so the chat `_process-run` dispatch lands on it with the real long budget.
  */
 function isDurableBackgroundDeployEnabled(): boolean {
   const raw = process.env.AGENT_CHAT_DURABLE_BACKGROUND;
-  if (raw == null) return false;
+  if (raw == null) return true;
   const v = raw.trim().toLowerCase();
-  return v === "1" || v === "true" || v === "yes" || v === "on";
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
 }
 
 /**

package/corpus/core/src/templates/default/_gitignore

@@ -10,6 +10,7 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+node-compile-cache/
 dist
 dist-ssr
 *.local

package/corpus/core/src/templates/headless/_gitignore

@@ -7,6 +7,7 @@ npm-debug.log*
 pnpm-debug.log*
 
 node_modules
+node-compile-cache/
 dist
 *.local
 

package/corpus/core/src/templates/workspace-root/_gitignore

@@ -28,6 +28,7 @@ packages/*/.env
 # pnpm
 .pnpm-store/
 pnpm-debug.log*
+node-compile-cache/
 
 # Local workspace data
 data/

package/corpus/templates/clips/actions/list-recordings.ts

@@ -55,6 +55,15 @@ export default defineAction({
       .describe("Sort order"),
     limit: z.coerce.number().int().min(1).max(500).default(100),
     offset: z.coerce.number().int().min(0).default(0),
+    countOnly: z
+      // Robust coercion: a GET query param arrives as the string "true"/"false",
+      // and z.coerce.boolean would treat "false" as true. Map strings explicitly.
+      .preprocess(
+        (v) => (typeof v === "string" ? v === "true" : v),
+        z.boolean(),
+      )
+      .default(false)
+      .describe("Return only the total count, skipping the row payload"),
   }),
   http: { method: "GET" },
   run: async (args) => {
@@ -135,6 +144,18 @@ export default defineAction({
       );
     }
 
+    // Count-only callers (e.g. the sidebar badge) need just the total for the
+    // same filters, ignoring limit/offset. Run the COUNT and short-circuit
+    // before the row select, joins, and tag/view subqueries. Keeping it inside
+    // this branch means the normal list path doesn't pay for an extra query.
+    if (args.countOnly) {
+      const totalRows = await db
+        .select({ count: sql<number>`COUNT(1)` })
+        .from(schema.recordings)
+        .where(and(...whereClauses));
+      return { recordings: [], total: Number(totalRows[0]?.count ?? 0) };
+    }
+
     // Sort
     const viewCountOrder = sql<number>`(
       SELECT COUNT(1)

package/corpus/templates/clips/app/components/library/library-layout.tsx

@@ -46,6 +46,7 @@ import {
   useSpaces,
   useOrganizations,
   useCreateFolder,
+  useRecordingsCount,
 } from "@/hooks/use-library";
 import { useIsMobile } from "@/hooks/use-mobile";
 import { useDesktopPromo } from "@/hooks/use-desktop-promo";
@@ -124,6 +125,10 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
     { enabled: hasActiveOrg && Boolean(currentOrganizationId) },
   );
 
+  // Clip count for the "Library" nav item — count-only, no row payload or
+  // title polling across the app shell.
+  const { data: libraryCount } = useRecordingsCount({ view: "library" });
+
   const libFolderList: FolderNode[] = useMemo(
     () =>
       (libFolders?.folders ?? [])
@@ -176,12 +181,14 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
     label: string;
     icon: React.ComponentType<{ className?: string }>;
     match: (path: string) => boolean;
+    count?: number;
   }[] = [
     {
       to: "/library",
       label: "Library",
       icon: IconInbox,
       match: (p) => p.startsWith("/library"),
+      count: libraryCount,
     },
     {
       to: "/spaces",
@@ -374,7 +381,7 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
                   </div>
 
                   <nav className="mt-3 space-y-0.5 px-2">
-                    {navItems.map(({ to, label, icon: Icon, match }) => {
+                    {navItems.map(({ to, label, icon: Icon, match, count }) => {
                       const active = match(location.pathname);
                       return (
                         <NavLink
@@ -388,7 +395,19 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
                           )}
                         >
                           <Icon className="h-4 w-4" />
-                          {label}
+                          <span className="flex-1 truncate">{label}</span>
+                          {count !== undefined && count > 0 && (
+                            <span
+                              className={cn(
+                                "shrink-0 tabular-nums text-[11px]",
+                                active
+                                  ? "text-primary/80"
+                                  : "text-muted-foreground",
+                              )}
+                            >
+                              {count}
+                            </span>
+                          )}
                         </NavLink>
                       );
                     })}

package/corpus/templates/clips/app/hooks/use-library.ts

@@ -87,6 +87,24 @@ export function useRecordings(args: ListRecordingsArgs = {}) {
   );
 }
 
+/**
+ * Count-only variant for surfaces like the sidebar badge that need a total but
+ * not the rows. Hits `list-recordings` with `countOnly`, so it skips the row
+ * payload server-side and doesn't share (or pay for) the full-list query or its
+ * title polling.
+ */
+export function useRecordingsCount(
+  args: Omit<ListRecordingsArgs, "limit" | "offset"> = {},
+) {
+  return useActionQuery<number>(
+    "list-recordings",
+    { ...args, countOnly: true } as any,
+    {
+      select: (data: any) => (typeof data?.total === "number" ? data.total : 0),
+    },
+  );
+}
+
 export interface SearchHit {
   id: string;
   title: string;

package/corpus/templates/plan/.agents/skills/visual-plan/SKILL.md

@@ -489,14 +489,16 @@ sign-in at setup — this is intended), so the first tool call in that client do
 not hit an OAuth wall:
 
 ```bash
-npx @agent-native/core@latest skills add visual-plan
+npx @agent-native/core@latest skills add visual-plans
 ```
 
 After that, `/visual-plan` and `/visual-recap` are the two installed slash
-commands. The other planning modes (`create-ui-plan`, `create-prototype-plan`,
-`create-plan-design`, `create-visual-questions`) are MCP tools reachable from
-`/visual-plan`, not separate slash commands. Pass `--no-connect` to register
-the connector without authenticating, then run
+commands. If you only need one command, use `skills add visual-plan` or
+`skills add visual-recap` instead. The other planning modes
+(`create-ui-plan`, `create-prototype-plan`, `create-plan-design`,
+`create-visual-questions`) are MCP tools reachable from `/visual-plan`, not
+separate slash commands. Pass `--no-connect` to register the connector without
+authenticating, then run
 `npx @agent-native/core@latest connect https://plan.agent-native.com --client all`
 whenever you are ready, or choose a narrower `--client`. Auth and MCP tool
 loading are per client config/session.

package/dist/agent/durable-background.d.ts

@@ -23,6 +23,31 @@ export declare const AGENT_CHAT_BACKGROUND_RUN_FIELD = "__backgroundRun";
  * what "hosted" means.
  */
 export declare function isHostedRuntimeForDurableBackground(): boolean;
+/**
+ * True when THIS process is actually executing inside a Netlify *background*
+ * function (the long, 15-min-budget async function whose deployed name ends in
+ * `-background`). Netlify runs functions on AWS Lambda and sets
+ * `AWS_LAMBDA_FUNCTION_NAME` to the function's name, so a `-background` suffix is
+ * the runtime proof that the ~60s synchronous wall does NOT apply here.
+ *
+ * This is the SAFETY GUARD for the soft-timeout regime. The `_process-run`
+ * self-dispatch worker (`isBackgroundWorker`) is NOT enough on its own: if the
+ * `-background` function was never emitted (deploy gate off, or Netlify routed
+ * the path to the synchronous function), the self-POST lands on the regular
+ * ~60s `server` function. A worker there MUST use the 40s soft-timeout and
+ * checkpoint before the 60s wall — using the ~13min budget would overshoot the
+ * hard wall and get killed at 60s, then re-dispatch/resume in a wasteful loop.
+ * So the 13-min budget is taken ONLY when this returns true.
+ *
+ * The PRIMARY signal is a `globalThis` marker the emitted background function's
+ * entry sets at cold start — the deployed Lambda name is not guaranteed to end
+ * in `-background` on Netlify, so the entry marks its own runtime. A `globalThis`
+ * flag (not `process.env`) keeps the no-env-mutation guard satisfied and carries
+ * no cross-request state (set once per isolate). The `AWS_LAMBDA_FUNCTION_NAME`
+ * suffix and the explicit `AGENT_CHAT_FORCE_BACKGROUND_RUNTIME` env (truthy) are
+ * additional signals — the latter an operator escape hatch. Off by default.
+ */
+export declare function isInBackgroundFunctionRuntime(): boolean;
 /**
  * The single gate. True when the flag is not explicitly disabled (default-on)
  * AND the runtime is hosted AND A2A_SECRET is configured. False otherwise — and

package/dist/agent/durable-background.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AA6CA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAyBD;;;;;;GAMG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAM7D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CA0CvB"}
+{"version":3,"file":"durable-background.d.ts","sourceRoot":"","sources":["../../src/agent/durable-background.ts"],"names":[],"mappings":"AA6CA;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,2CACE,CAAC;AAE3C;;;GAGG;AACH,eAAO,MAAM,iCAAiC,kCACb,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBAAoB,CAAC;AAEjE;;;;GAIG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAsB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD;AAyBD;;;;;;GAMG;AACH,wBAAgB,mCAAmC,IAAI,OAAO,CAM7D;AAED,uDAAuD;AACvD,MAAM,MAAM,qBAAqB,GAC7B;IACE,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,qBAAqB,CA0CvB"}