@agent-native/core 0.222.2-nightly-20261029152548 → 0.222.2

package/dist/client/agent-run-status.d.ts

@@ -5,6 +5,8 @@ export type AgentRunStatusRead = {
     runId?: string;
     turnId?: string;
     terminalReason?: string;
+    /** A truncated run whose continuation the server has not started yet. */
+    awaitingRedispatch?: boolean;
 } | {
     ok: false;
 };

package/dist/client/agent-run-status.js

@@ -38,6 +38,9 @@ export async function readAgentRunStatus(input) {
             ...(typeof state.terminalReason === "string" && state.terminalReason
                 ? { terminalReason: state.terminalReason }
                 : {}),
+            ...(state.awaitingRedispatch === true
+                ? { awaitingRedispatch: true }
+                : {}),
         };
     }
     catch {

package/dist/client/chat/agentkit-agent-native.js

@@ -3416,6 +3416,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                 threadId: input.threadId,
                 tabId: input.threadId,
                 runId: run.runId,
+                reason: "run.submitted",
             });
             return run;
         }

package/dist/client/use-agent-chat-running-threads.d.ts

@@ -7,6 +7,10 @@ export interface AgentChatRunningEventDetail {
     tabId?: string;
     turnId?: string;
     runId?: string;
+    /**
+     * `"run.submitted"` marks the run this client just started for a submitted
+     * message, which carries no successor link to any earlier run.
+     */
     reason?: string;
 }
 export interface UseAgentChatRunningThreadsOptions {

package/dist/deploy/build.js

@@ -17,7 +17,7 @@ import { RECURRING_JOBS_BUILD_MARKER_ENV_VAR, resolveRecurringJobsBuildMarker, }
 import { normalizeAppBasePath } from "../server/app-base-path.js";
 import { frameworkSessionHintCookieName, resolveAuthCookieNamespace, } from "../server/cookie-namespace.js";
 import { resolveAgentNativeBuildId } from "../shared/build-id.js";
-import { DEFAULT_SPECULATION_RULES_PATH, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
+import { CHUNK_RECOVERY_BROWSER_CACHE_CONTROL, DEFAULT_SPECULATION_RULES_PATH, DISABLED_SSR_CACHE_HEADERS, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrCachePolicy, SSR_CACHEABLE_ERROR_STATUSES, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, ssrRouteCacheLimits, } from "../shared/cache-control.js";
 import { EMBED_TARGET_QUERY_PARAM, EMBED_TOKEN_QUERY_PARAM, } from "../shared/embed-auth.js";
 import { FRAMEWORK_INTERNAL_ROUTE_PREFIX, normalizeFrameworkRoutePrefix, toPublicFrameworkPath, } from "../shared/framework-route-prefix.js";
 import { mcpEmbedStaticAssetRouteRules } from "../shared/mcp-embed-headers.js";
@@ -1090,6 +1090,7 @@ export function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = []
     const ssrCacheHeaders = resolveSsrCacheHeaders();
     const chunkRecoveryCacheHeaders = resolveChunkRecoveryCacheHeaders(ssrCacheHeaders);
     const ssrCacheKeyHeaders = resolveSsrCacheKeyHeaders();
+    const ssrRouteLimits = ssrRouteCacheLimits(resolveSsrCachePolicy());
     const ssrAuthRedirectCookieName = frameworkSessionHintCookieName(resolveAuthCookieNamespace().frameworkCookieName);
     const hasActions = actions.length > 0;
     const routeImports = [];
@@ -1806,6 +1807,13 @@ const SSR_CACHE_HEADERS = ${JSON.stringify(ssrCacheHeaders)};
 const CHUNK_RECOVERY_ALIAS_CACHE_HEADERS = ${JSON.stringify(chunkRecoveryCacheHeaders)};
 const SSR_CACHE_KEY_HEADERS = ${JSON.stringify(ssrCacheKeyHeaders)};
 const SSR_QUERY_CACHE_KEY_HEADER = ${JSON.stringify(SSR_QUERY_CACHE_KEY_HEADER)};
+const SSR_MAX_AGE_HEADER = ${JSON.stringify(SSR_MAX_AGE_HEADER)};
+// The longest windows a route's SSR_MAX_AGE_HEADER can ask for; null when the
+// deployment stores nothing.
+const SSR_ROUTE_CACHE_LIMITS = ${JSON.stringify(ssrRouteLimits)};
+const SSR_UNSTORED_CACHE_HEADERS = ${JSON.stringify(DISABLED_SSR_CACHE_HEADERS)};
+const SSR_ROUTE_BROWSER_CACHE_CONTROL = ${JSON.stringify(CHUNK_RECOVERY_BROWSER_CACHE_CONTROL)};
+const SSR_CACHEABLE_ERROR_STATUSES = new Set(${JSON.stringify(SSR_CACHEABLE_ERROR_STATUSES)});
 const CHUNK_RECOVERY_PATH_SUFFIX = ${JSON.stringify(CHUNK_RECOVERY_PATH_SUFFIX)};
 const CHUNK_RECOVERY_QUERY_PARAM = ${JSON.stringify(CHUNK_RECOVERY_QUERY_PARAM)};
 const CHUNK_RECOVERY_QUERY_VALUE = ${JSON.stringify(CHUNK_RECOVERY_QUERY_VALUE)};
@@ -1874,12 +1882,40 @@ function injectDefaultSocialImageMeta(html, imageUrl) {
 }
 
 function isSsrHtmlOrDataResponse(headers, status, pathname) {
-  if (status < 200 || status >= 400) return false;
+  if (status < 200) return false;
+  if (status >= 400 && !SSR_CACHEABLE_ERROR_STATUSES.has(status)) return false;
   const contentType = (headers.get("content-type") || "").toLowerCase();
   if (contentType.includes("text/html")) return true;
   return pathname.endsWith(".data") && contentType.includes("text/x-script");
 }
 
+// Mirror parseSsrMaxAge and ssrCacheHeadersWithin in shared/cache-control.ts;
+// build.spec.ts checks this worker against them.
+function parseSsrMaxAge(raw) {
+  if (raw == null) return null;
+  const value = raw.trim();
+  return /^\\d+$/.test(value) ? Number(value) : 0;
+}
+
+function sharedWithin(window, seconds) {
+  return (
+    "s-maxage=" +
+    Math.min(seconds, window.maxAge) +
+    ", stale-while-revalidate=" +
+    Math.min(seconds, window.stale)
+  );
+}
+
+function ssrCacheHeadersWithin(seconds) {
+  if (!SSR_ROUTE_CACHE_LIMITS || seconds <= 0) return SSR_UNSTORED_CACHE_HEADERS;
+  return {
+    "cache-control": SSR_ROUTE_BROWSER_CACHE_CONTROL,
+    "cdn-cache-control": "public, " + sharedWithin(SSR_ROUTE_CACHE_LIMITS.cdn, seconds),
+    "netlify-cdn-cache-control":
+      "public, durable, " + sharedWithin(SSR_ROUTE_CACHE_LIMITS.netlify, seconds),
+  };
+}
+
 /**
  * Apply the SSR cache policy to the response headers.
  *
@@ -1891,6 +1927,8 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
   const varyByQuery =
     (headers.get(SSR_QUERY_CACHE_KEY_HEADER) || "").trim().toLowerCase() === "query";
   headers.delete(SSR_QUERY_CACHE_KEY_HEADER);
+  const routeMaxAge = parseSsrMaxAge(headers.get(SSR_MAX_AGE_HEADER));
+  headers.delete(SSR_MAX_AGE_HEADER);
   if (!isSsrHtmlOrDataResponse(headers, status, pathname)) return;
 
   headers.delete("set-cookie");
@@ -1907,7 +1945,9 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
     else headers.delete("vary");
   }
 
-  for (const [name, value] of Object.entries(SSR_CACHE_HEADERS)) {
+  const cacheHeaders =
+    routeMaxAge === null ? SSR_CACHE_HEADERS : ssrCacheHeadersWithin(routeMaxAge);
+  for (const [name, value] of Object.entries(cacheHeaders)) {
     headers.set(name, value);
   }
   const netlifyVary = varyByQuery

package/dist/localization/default-messages.d.ts

@@ -104,6 +104,11 @@ declare const messages: {
         composer: {
             chatgptManageUsage: string;
             chatgptPlanUsing: string;
+            newChatPlaceholder: string;
+        };
+        setup: {
+            connectBuilder: string;
+            connectPlaceholder: string;
         };
         error: {
             chatgptPlanUsageLimit: string;

package/dist/localization/default-messages.js

@@ -28,6 +28,11 @@ const messages = {
         composer: {
             chatgptManageUsage: "Manage usage",
             chatgptPlanUsing: "Using ChatGPT plan",
+            newChatPlaceholder: "Ask anything",
+        },
+        setup: {
+            connectBuilder: "Connect Builder.io",
+            connectPlaceholder: "Connect AI to start chatting...",
         },
         error: {
             chatgptPlanUsageLimit: "Your ChatGPT plan usage limit has been reached.",

package/dist/server/ssr-handler.js

@@ -2,7 +2,7 @@ import { defineEventHandler } from "h3";
 import { createRequestHandler } from "react-router";
 import { getAppConfig, resolveAppHomePath } from "../app-config/index.js";
 import { isMcpPublicPath } from "../mcp/route-paths.js";
-import { DEFAULT_SPECULATION_RULES_PATH, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, SSR_QUERY_CACHE_KEY_HEADER, } from "../shared/cache-control.js";
+import { DEFAULT_SPECULATION_RULES_PATH, parseSsrMaxAge, resolveChunkRecoveryCacheHeaders, resolveSsrCacheHeaders, resolveSsrCacheKeyHeaders, resolveSsrCachePolicy, SSR_CACHEABLE_ERROR_STATUSES, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, ssrCacheHeadersWithin, } from "../shared/cache-control.js";
 import { CHUNK_RECOVERY_PATH_SUFFIX, isLegacyChunkRecoveryRequest, } from "../shared/route-chunk-recovery-bootstrap.js";
 import { AGENT_NATIVE_SOCIAL_IMAGE_ALT, AGENT_NATIVE_SOCIAL_IMAGE_HEIGHT, AGENT_NATIVE_SOCIAL_IMAGE_PATH, AGENT_NATIVE_SOCIAL_IMAGE_TYPE, AGENT_NATIVE_SOCIAL_IMAGE_WIDTH, withAgentNativeSocialImageCacheBuster, } from "../shared/social-meta.js";
 import { getSsrAuthRedirectScript } from "../shared/ssr-auth-redirect.js";
@@ -186,7 +186,7 @@ function injectDefaultSocialImageMeta(html, imageUrl) {
         return html;
     return html.slice(0, headCloseIdx) + tags.join("") + html.slice(headCloseIdx);
 }
-const CACHEABLE_ERROR_STATUSES = new Set([404, 410]);
+const CACHEABLE_ERROR_STATUSES = new Set(SSR_CACHEABLE_ERROR_STATUSES);
 function isSsrHtmlOrDataResponse(headers, status, pathname) {
     if (status < 200)
         return false;
@@ -227,6 +227,11 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
  * │ PER-USER response variation — no `private`, no `Vary: Cookie`, and no     │
  * │ request-specific content. Recovery keeps a bounded alias and never adds  │
  * │ arbitrary query-key variation to the normally cached shell.               │
+ * │                                                                            │
+ * │ A route whose content can change or be taken down may SHORTEN its own     │
+ * │ window with `SSR_MAX_AGE_HEADER`: one duration for every visitor of that  │
+ * │ route, never longer than the deployment's, so it can't personalize the    │
+ * │ shell or poison a shared key.                                              │
  * └──────────────────────────────────────────────────────────────────────────┘
  *
  * The same sharing rule governs any DIAGNOSTIC header on this response. A
@@ -240,6 +245,8 @@ function isSsrHtmlOrDataResponse(headers, status, pathname) {
 function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias = false, isLegacyRecovery = false) {
     const responseRequestsQueryVary = headers.get(SSR_QUERY_CACHE_KEY_HEADER)?.trim().toLowerCase() === "query";
     headers.delete(SSR_QUERY_CACHE_KEY_HEADER);
+    const routeMaxAge = parseSsrMaxAge(headers.get(SSR_MAX_AGE_HEADER));
+    headers.delete(SSR_MAX_AGE_HEADER);
     if (!isSsrHtmlOrDataResponse(headers, status, pathname))
         return;
     // Current recovery uses one fixed path alias. Still-deployed clients use the
@@ -267,7 +274,10 @@ function applyDefaultSsrCacheHeader(headers, status, pathname, isRecoveryAlias =
         else
             headers.delete("vary");
     }
-    for (const [name, value] of Object.entries(resolveSsrCacheHeaders())) {
+    const cacheHeaders = routeMaxAge === null
+        ? resolveSsrCacheHeaders()
+        : ssrCacheHeadersWithin(resolveSsrCachePolicy(), routeMaxAge);
+    for (const [name, value] of Object.entries(cacheHeaders)) {
         headers.set(name, value);
     }
     const cacheKeyHeaders = resolveSsrCacheKeyHeaders(undefined, {

package/dist/shared/cache-control.d.ts

@@ -10,6 +10,20 @@ export declare const DEFAULT_SSR_CACHE_HEADERS: {
 };
 export declare const SSR_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export declare const SSR_QUERY_CACHE_KEY_HEADER = "x-agent-native-ssr-key";
+/**
+ * Response header a route sets to the most seconds its SSR response may be
+ * kept anywhere, for a page whose content can change or be taken down (a
+ * public share page, say). The SSR handler reads and removes it. It only ever
+ * shortens the deployment's policy, and it names one duration for every
+ * visitor of the route, so it can't vary the shell per request or per user.
+ * `0` means don't store it at all.
+ */
+export declare const SSR_MAX_AGE_HEADER = "x-agent-native-ssr-max-age";
+/**
+ * Error statuses whose SSR HTML/`.data` answer still gets the shared cache
+ * policy: a missing or removed page is the same for every visitor.
+ */
+export declare const SSR_CACHEABLE_ERROR_STATUSES: readonly number[];
 export type SsrHtmlContentTypeOptions = {
     varyByQuery?: boolean;
 };
@@ -32,6 +46,39 @@ export type SsrCachePolicy = {
 export type SsrCacheHeaders = Record<"cache-control" | "cdn-cache-control" | "netlify-cdn-cache-control", string>;
 export declare function parseSsrCacheSetting(raw: string | undefined | null): SsrCachePolicy;
 export declare function ssrCacheHeadersForPolicy(policy: SsrCachePolicy): SsrCacheHeaders;
+/**
+ * The route's `SSR_MAX_AGE_HEADER` value in seconds, or null when unset. A
+ * value that isn't whole seconds reads as 0: the route asked for a shorter
+ * window, and falling back to the deployment's would keep a page it takes
+ * down for as long as that window.
+ */
+export declare function parseSsrMaxAge(raw: string | null | undefined): number | null;
+export type SsrSharedWindow = {
+    maxAge: number;
+    stale: number;
+};
+export type SsrRouteCacheLimits = {
+    cdn: SsrSharedWindow;
+    netlify: SsrSharedWindow;
+};
+/**
+ * The longest shared-cache windows a route's `SSR_MAX_AGE_HEADER` can ask for
+ * under `policy`, read from the headers the deployment would send, one per CDN
+ * header since they differ. Null when the deployment stores nothing. The
+ * generated edge worker inlines these at build time.
+ */
+export declare function ssrRouteCacheLimits(policy: SsrCachePolicy): SsrRouteCacheLimits | null;
+/**
+ * The deployment's policy with every window cut to at most `seconds`, for a
+ * route that set `SSR_MAX_AGE_HEADER`. Browsers revalidate on each visit, so
+ * shared caches alone bound how old a copy gets: fresh for `seconds`, then
+ * served once more while it refreshes, so never more than twice `seconds`
+ * after the render. Nothing is served stale on origin errors either, since a
+ * page taken down must not come back while origin is failing.
+ */
+export declare function ssrCacheHeadersWithin(policy: SsrCachePolicy, seconds: number): SsrCacheHeaders;
+/** The deployment-wide policy from `AGENT_NATIVE_SSR_CACHE`. */
+export declare function resolveSsrCachePolicy(env?: Record<string, string | undefined>): SsrCachePolicy;
 export declare function resolveSsrCacheHeaders(env?: Record<string, string | undefined>): Readonly<SsrCacheHeaders>;
 export declare function resolveChunkRecoveryCacheHeaders(cacheHeaders?: Pick<SsrCacheHeaders, "cache-control">): Readonly<SsrCacheHeaders>;
 export declare function resolveSsrNetlifyQueryVary(varyByQuery?: boolean, varyByLegacyRecovery?: boolean): string;

package/dist/shared/cache-control.js

@@ -11,6 +11,20 @@ export const DEFAULT_SSR_CACHE_HEADERS = {
 };
 export const SSR_HTML_CONTENT_TYPE = "text/html; charset=utf-8";
 export const SSR_QUERY_CACHE_KEY_HEADER = "x-agent-native-ssr-key";
+/**
+ * Response header a route sets to the most seconds its SSR response may be
+ * kept anywhere, for a page whose content can change or be taken down (a
+ * public share page, say). The SSR handler reads and removes it. It only ever
+ * shortens the deployment's policy, and it names one duration for every
+ * visitor of the route, so it can't vary the shell per request or per user.
+ * `0` means don't store it at all.
+ */
+export const SSR_MAX_AGE_HEADER = "x-agent-native-ssr-max-age";
+/**
+ * Error statuses whose SSR HTML/`.data` answer still gets the shared cache
+ * policy: a missing or removed page is the same for every visitor.
+ */
+export const SSR_CACHEABLE_ERROR_STATUSES = [404, 410];
 export function withSsrHtmlContentType(response, options = {}) {
     response.headers.set("content-type", SSR_HTML_CONTENT_TYPE);
     if (options.varyByQuery) {
@@ -73,8 +87,84 @@ export function ssrCacheHeadersForPolicy(policy) {
         "netlify-cdn-cache-control": netlifyControl,
     };
 }
+/**
+ * The route's `SSR_MAX_AGE_HEADER` value in seconds, or null when unset. A
+ * value that isn't whole seconds reads as 0: the route asked for a shorter
+ * window, and falling back to the deployment's would keep a page it takes
+ * down for as long as that window.
+ */
+export function parseSsrMaxAge(raw) {
+    if (raw == null)
+        return null;
+    const value = raw.trim();
+    if (!/^\d+$/.test(value))
+        return 0;
+    return Math.min(Number(value), MAX_SSR_CACHE_SECONDS);
+}
+function directiveSeconds(control, name) {
+    const match = new RegExp(`(?:^|,)\\s*${name}=(\\d+)\\s*(?:,|$)`, "i").exec(control);
+    return match ? Number(match[1]) : null;
+}
+function sharedWindow(control) {
+    return {
+        maxAge: directiveSeconds(control, "s-maxage") ??
+            directiveSeconds(control, "max-age") ??
+            0,
+        stale: directiveSeconds(control, "stale-while-revalidate") ?? 0,
+    };
+}
+/**
+ * The longest shared-cache windows a route's `SSR_MAX_AGE_HEADER` can ask for
+ * under `policy`, read from the headers the deployment would send, one per CDN
+ * header since they differ. Null when the deployment stores nothing. The
+ * generated edge worker inlines these at build time.
+ */
+export function ssrRouteCacheLimits(policy) {
+    if (policy.kind === "disabled")
+        return null;
+    const headers = ssrCacheHeadersForPolicy(policy);
+    return {
+        cdn: sharedWindow(headers["cdn-cache-control"]),
+        netlify: sharedWindow(headers["netlify-cdn-cache-control"]),
+    };
+}
+function sharedWithin(window, seconds) {
+    return (`s-maxage=${Math.min(seconds, window.maxAge)}, ` +
+        `stale-while-revalidate=${Math.min(seconds, window.stale)}`);
+}
+/**
+ * The deployment's policy with every window cut to at most `seconds`, for a
+ * route that set `SSR_MAX_AGE_HEADER`. Browsers revalidate on each visit, so
+ * shared caches alone bound how old a copy gets: fresh for `seconds`, then
+ * served once more while it refreshes, so never more than twice `seconds`
+ * after the render. Nothing is served stale on origin errors either, since a
+ * page taken down must not come back while origin is failing.
+ */
+export function ssrCacheHeadersWithin(policy, seconds) {
+    const limits = ssrRouteCacheLimits(policy);
+    if (!limits || seconds <= 0)
+        return { ...DISABLED_SSR_CACHE_HEADERS };
+    return {
+        "cache-control": CHUNK_RECOVERY_BROWSER_CACHE_CONTROL,
+        "cdn-cache-control": `public, ${sharedWithin(limits.cdn, seconds)}`,
+        "netlify-cdn-cache-control": `public, durable, ${sharedWithin(limits.netlify, seconds)}`,
+    };
+}
 let memoizedRaw;
 let memoizedHeaders;
+let memoizedPolicyRaw;
+let memoizedPolicy;
+/** The deployment-wide policy from `AGENT_NATIVE_SSR_CACHE`. */
+export function resolveSsrCachePolicy(env = typeof process === "undefined"
+    ? {}
+    : process.env) {
+    const raw = env[SSR_CACHE_ENV_VAR];
+    if (memoizedPolicy && raw === memoizedPolicyRaw)
+        return memoizedPolicy;
+    memoizedPolicyRaw = raw;
+    memoizedPolicy = parseSsrCacheSetting(raw);
+    return memoizedPolicy;
+}
 export function resolveSsrCacheHeaders(env = typeof process === "undefined"
     ? {}
     : process.env) {

package/dist/shared/index.d.ts

@@ -22,7 +22,7 @@ export { formatAgentDesignSystemContext, loadAgentDesignSystemContext, type Agen
 export { formatHtmlStyleSummary, summarizeHtmlStyles, type HtmlStyleFragment, type HtmlStyleSummary, type HtmlStyleValue, } from "./html-style-summary.js";
 export { withBuilderUtmTrackingParams } from "./builder-link-tracking.js";
 export { BETA_FORCE_QUERY_PARAM, BETA_FORCE_SESSION_STORAGE_KEY, BETA_LANE_REDIRECT_QUERY_PARAM, BETA_LANE_RETURN_STORAGE_KEY, BETA_LANE_RETURNED_STORAGE_KEY, BETA_REDIRECT_DURATION_MS, BETA_REDIRECT_STORAGE_KEY, BETA_REDIRECT_SIGN_OUT_STORAGE_KEY, BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAGE_KEY, buildAutomaticBetaRedirectUrl, ENVIRONMENT_BETA_HOSTS, resolveEnvironmentTargets, type EnvironmentBadgeTargets, } from "./environment-lanes.js";
-export { SSR_HTML_CONTENT_TYPE, SSR_QUERY_CACHE_KEY_HEADER, type SsrHtmlContentTypeOptions, withSsrHtmlContentType, } from "./cache-control.js";
+export { SSR_HTML_CONTENT_TYPE, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, type SsrHtmlContentTypeOptions, withSsrHtmlContentType, } from "./cache-control.js";
 export { SURFACE_HIDDEN_FLAG, SURFACE_VISIBILITY_EVENT, addSurfaceVisibilityListener, buildSurfaceVisibilityScript, isHostSurfaceHidden, isSurfaceHidden, } from "./surface-visibility.js";
 export { AGENT_NATIVE_DOCS_ORIGIN, docsUrl, type DocsUrlOptions, } from "./docs-url.js";
 export { buildRuntimeConfigPrompt, formatRuntimeConfigReport, getRuntimeConfigReport, parseRuntimeConfigReport, runtimeConfigRequirementsFromSearchParams, type RuntimeConfigEnvironment, type RuntimeConfigIssue, type RuntimeConfigIssueCode, type RuntimeConfigIssueSeverity, type RuntimeConfigPhase, type RuntimeConfigReport, type RuntimeConfigRequirements, } from "./runtime-config.js";

package/dist/shared/index.js

@@ -22,7 +22,7 @@ export { formatAgentDesignSystemContext, loadAgentDesignSystemContext, } from ".
 export { formatHtmlStyleSummary, summarizeHtmlStyles, } from "./html-style-summary.js";
 export { withBuilderUtmTrackingParams } from "./builder-link-tracking.js";
 export { BETA_FORCE_QUERY_PARAM, BETA_FORCE_SESSION_STORAGE_KEY, BETA_LANE_REDIRECT_QUERY_PARAM, BETA_LANE_RETURN_STORAGE_KEY, BETA_LANE_RETURNED_STORAGE_KEY, BETA_REDIRECT_DURATION_MS, BETA_REDIRECT_STORAGE_KEY, BETA_REDIRECT_SIGN_OUT_STORAGE_KEY, BETA_OPT_OUT_DURATION_MS, BETA_OPT_OUT_QUERY_PARAM, BETA_OPT_OUT_STORAGE_KEY, buildAutomaticBetaRedirectUrl, ENVIRONMENT_BETA_HOSTS, resolveEnvironmentTargets, } from "./environment-lanes.js";
-export { SSR_HTML_CONTENT_TYPE, SSR_QUERY_CACHE_KEY_HEADER, withSsrHtmlContentType, } from "./cache-control.js";
+export { SSR_HTML_CONTENT_TYPE, SSR_MAX_AGE_HEADER, SSR_QUERY_CACHE_KEY_HEADER, withSsrHtmlContentType, } from "./cache-control.js";
 export { SURFACE_HIDDEN_FLAG, SURFACE_VISIBILITY_EVENT, addSurfaceVisibilityListener, buildSurfaceVisibilityScript, isHostSurfaceHidden, isSurfaceHidden, } from "./surface-visibility.js";
 export { AGENT_NATIVE_DOCS_ORIGIN, docsUrl, } from "./docs-url.js";
 export { buildRuntimeConfigPrompt, formatRuntimeConfigReport, getRuntimeConfigReport, parseRuntimeConfigReport, runtimeConfigRequirementsFromSearchParams, } from "./runtime-config.js";

package/dist/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -163,9 +163,21 @@ checkout, or the expected worktree is missing, create one
 to stop.
 
 Window: roots posted in the last 5 days (or since the timestamp or permalink
-the invocation gives), for new reports and open items alike. Older threads
-are left as they are, except reports listed under `Reports` in a sweep PR
-opened or merged in that window: those always get their close-out.
+the invocation gives), for new reports and open items alike. An older thread
+is in the window too when we have already replied in it and a person has
+replied since the window began: a channel read only shows roots, so search for
+recent thread replies (`in:<#channel> is:thread after:<date>`) to find them.
+On 10/29 a teammate's vote and question sat unanswered under a 3-week-old
+root. Other older threads are left as they are, except reports listed under
+`Reports` in a sweep PR opened or merged in that window: those always get
+their close-out.
+
+Reading a source is a good job for a helper: give each source below its own
+helper on the cheapest model (Luna in Codex, Haiku in Claude Code), ask for a
+short list of candidates with links, and close it as soon as it reports. On
+10/29 the three source reads cost $0.44 together; reusing those same helpers
+for fixes afterwards cost $6.36, because each new job paid for its whole
+growing history.
 
 - **Read the channels.** Use `slack_read_channel` with
   `response_format: detailed` (paginate) back 5 days. Its output shows
@@ -250,8 +262,9 @@ apart from Steve's own 👀.
 ## 3. Fix as many as you can
 
 - Group related reports so one cause gets one fix. Give each independent
-  group a subagent on a cheaper model with disjoint files. The main thread
-  plans, reviews diffs, and integrates.
+  group a fresh subagent on your own model and effort, with disjoint files,
+  or fix it in the main thread. Never hand a finished helper a new job; start
+  a fresh one. The main thread plans, reviews diffs, and integrates.
 - **Reproduce before you edit.** Get the failure on screen first: a test
   that fails, the action returning the wrong thing, a stack trace, or the
   flow broken in a signed-in local app. Reading code is not an attempt:
@@ -274,9 +287,12 @@ apart from Steve's own 👀.
   green, stop editing and capture the real failure first (stack, logs, the
   reporter's actual data). If that doesn't settle it within about 30
   minutes, it becomes 🎫 with one line on what you learned.
-- **Second opinion before the PR.** Give a fresh subagent only the report
-  text, the diff, and the proof, and ask: does the check exercise what the
-  reporter saw, and is this the cause or a symptom? Fix what it finds.
+- **Second opinion before the PR, every time.** Give a fresh subagent on
+  your own model only the report text, the diff, and the proof, and ask: does
+  the check exercise what the reporter saw, is this the cause or a symptom,
+  and what edge case breaks it? Fix what it finds before you open the PR. The
+  10/29 run skipped this, and PR review found the edge cases one round at a
+  time instead.
 - **Keep fixes small.** Each report's fix goes in its own commit so a bad
   one can be reverted alone. A fix that grows past about 300 lines, or into
   a new subsystem (timeouts, cancellation, retries) the reporter didn't ask
@@ -293,6 +309,19 @@ PR per item. End the PR body with a
 Slack thread, or the Sentry, Analytics, or GitHub issue. That list is the
 only set of threads a later `/ship` may close out as fixed.
 
+Wait for CI with one blocking command, such as
+`gh pr checks <number> --watch --required --interval 60`, and don't post a
+status line while it runs: every turn re-sends your whole context, and on
+10/28 polling CI was half the main thread's cost.
+
+Fix each review round's findings in one batch. If a second round still finds
+a problem in the same fix, take that fix out of the PR, remove its whole entry
+from the PR's `Reports` section: the link and its `fix-proof:` and `visual:`
+lines (close-out marks every listed report fixed, and a stray evidence line
+counts toward the report above it). Then 🎫 its
+report with what review found, and merge the rest. Close the PR only when nothing verified
+is left in it.
+
 Merge it the way this repo merges PRs. In a Factory workspace, that means
 the workflow's merge step after its merge gate, never a direct merge.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.222.2-nightly-20261029152548",
+  "version": "0.222.2",
   "description": "The agentic application framework for building autonomous agents with intuitive UIs",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -742,8 +742,8 @@
     "yaml": "^2.9.0",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.222.2-nightly-20261029152548",
-    "@agent-native/recap-cli": "^0.5.92"
+    "@agent-native/agentkit": "^0.222.2",
+    "@agent-native/recap-cli": "^0.5.93"
   },
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.71",
@@ -814,7 +814,7 @@
     "xlsx": "^0.18.5"
   },
   "peerDependencies": {
-    "@agent-native/core-corpus": "0.222.2-nightly-20261029152548",
+    "@agent-native/core-corpus": ">=0.196.0",
     "@ai-sdk/anthropic": ">=3",
     "@ai-sdk/cohere": ">=3",
     "@ai-sdk/google": ">=3",

package/src/templates/factory/.agents/skills/review-latest-feedback/SKILL.md

@@ -163,9 +163,21 @@ checkout, or the expected worktree is missing, create one
 to stop.
 
 Window: roots posted in the last 5 days (or since the timestamp or permalink
-the invocation gives), for new reports and open items alike. Older threads
-are left as they are, except reports listed under `Reports` in a sweep PR
-opened or merged in that window: those always get their close-out.
+the invocation gives), for new reports and open items alike. An older thread
+is in the window too when we have already replied in it and a person has
+replied since the window began: a channel read only shows roots, so search for
+recent thread replies (`in:<#channel> is:thread after:<date>`) to find them.
+On 10/29 a teammate's vote and question sat unanswered under a 3-week-old
+root. Other older threads are left as they are, except reports listed under
+`Reports` in a sweep PR opened or merged in that window: those always get
+their close-out.
+
+Reading a source is a good job for a helper: give each source below its own
+helper on the cheapest model (Luna in Codex, Haiku in Claude Code), ask for a
+short list of candidates with links, and close it as soon as it reports. On
+10/29 the three source reads cost $0.44 together; reusing those same helpers
+for fixes afterwards cost $6.36, because each new job paid for its whole
+growing history.
 
 - **Read the channels.** Use `slack_read_channel` with
   `response_format: detailed` (paginate) back 5 days. Its output shows
@@ -250,8 +262,9 @@ apart from Steve's own 👀.
 ## 3. Fix as many as you can
 
 - Group related reports so one cause gets one fix. Give each independent
-  group a subagent on a cheaper model with disjoint files. The main thread
-  plans, reviews diffs, and integrates.
+  group a fresh subagent on your own model and effort, with disjoint files,
+  or fix it in the main thread. Never hand a finished helper a new job; start
+  a fresh one. The main thread plans, reviews diffs, and integrates.
 - **Reproduce before you edit.** Get the failure on screen first: a test
   that fails, the action returning the wrong thing, a stack trace, or the
   flow broken in a signed-in local app. Reading code is not an attempt:
@@ -274,9 +287,12 @@ apart from Steve's own 👀.
   green, stop editing and capture the real failure first (stack, logs, the
   reporter's actual data). If that doesn't settle it within about 30
   minutes, it becomes 🎫 with one line on what you learned.
-- **Second opinion before the PR.** Give a fresh subagent only the report
-  text, the diff, and the proof, and ask: does the check exercise what the
-  reporter saw, and is this the cause or a symptom? Fix what it finds.
+- **Second opinion before the PR, every time.** Give a fresh subagent on
+  your own model only the report text, the diff, and the proof, and ask: does
+  the check exercise what the reporter saw, is this the cause or a symptom,
+  and what edge case breaks it? Fix what it finds before you open the PR. The
+  10/29 run skipped this, and PR review found the edge cases one round at a
+  time instead.
 - **Keep fixes small.** Each report's fix goes in its own commit so a bad
   one can be reverted alone. A fix that grows past about 300 lines, or into
   a new subsystem (timeouts, cancellation, retries) the reporter didn't ask
@@ -293,6 +309,19 @@ PR per item. End the PR body with a
 Slack thread, or the Sentry, Analytics, or GitHub issue. That list is the
 only set of threads a later `/ship` may close out as fixed.
 
+Wait for CI with one blocking command, such as
+`gh pr checks <number> --watch --required --interval 60`, and don't post a
+status line while it runs: every turn re-sends your whole context, and on
+10/28 polling CI was half the main thread's cost.
+
+Fix each review round's findings in one batch. If a second round still finds
+a problem in the same fix, take that fix out of the PR, remove its whole entry
+from the PR's `Reports` section: the link and its `fix-proof:` and `visual:`
+lines (close-out marks every listed report fixed, and a stray evidence line
+counts toward the report above it). Then 🎫 its
+report with what review found, and merge the rest. Close the PR only when nothing verified
+is left in it.
+
 Merge it the way this repo merges PRs. In a Factory workspace, that means
 the workflow's merge step after its merge gate, never a direct merge.