@agent-native/core 0.176.1 → 0.176.2-nightly-20260831184159

package/corpus/templates/analytics/server/lib/workspace-feature-flags.ts

@@ -4,14 +4,18 @@ import { signA2AToken } from "@agent-native/core/a2a";
 import {
   ActionContractError,
   AgentActionStopError,
+  type ActionRunContext,
 } from "@agent-native/core/action";
 import { isFeatureFlagEnabled } from "@agent-native/core/feature-flags";
+import listLocalFeatureFlagsAction from "@agent-native/core/feature-flags/actions/list-feature-flags";
+import setLocalFeatureFlagAction from "@agent-native/core/feature-flags/actions/set-feature-flag";
 import {
   fetchOrgApps,
   fetchOrgAppsResult,
   type OrgApp,
 } from "@agent-native/core/mcp";
 import { getOrgDomain } from "@agent-native/core/org";
+import { getAppConfig } from "@agent-native/core/server";
 
 import {
   RESILIENT_FLEET_FLAG_DIRECTORY,
@@ -23,6 +27,7 @@ const TARGET_TIMEOUT_MS = 3_000;
 const DIRECTORY_ATTEMPTS = 2;
 const VERIFICATION_ATTEMPTS = 2;
 const CONCURRENCY = 4;
+const ANALYTICS_APP_ID = "analytics";
 
 export type FleetFlagState =
   | "ready"
@@ -91,6 +96,37 @@ export function workspaceFeatureFlagTargetInput(
     : rawTargetInput;
 }
 
+function mutationValidationExpectation(
+  admin: AnalyticsAdminContext,
+  input: WorkspaceFeatureFlagMutationInput,
+  orgDomain: string,
+) {
+  return {
+    key: input.key,
+    orgDomain,
+    allowExplicitNoOrgTarget: true,
+    ...(input.operation === "replace-rules" && input.rules
+      ? {
+          rules: {
+            mode: input.rules.mode,
+            emails: input.rules.emails ?? [],
+            orgIds: input.rules.orgIds ?? [],
+            percentage: input.rules.percentage ?? 0,
+          },
+        }
+      : input.operation === "off"
+        ? {
+            rules: {
+              mode: "off",
+              emails: [],
+              orgIds: [],
+              percentage: 0,
+            },
+          }
+        : { enabledForEmail: admin.userEmail }),
+  };
+}
+
 export function validateWorkspaceFeatureFlagMutation(
   body: unknown,
   expected: {
@@ -179,6 +215,54 @@ function targetOrigin(app: OrgApp): string {
   return new URL(app.url).origin;
 }
 
+function localAnalyticsApp(): OrgApp {
+  const configuredUrl = getAppConfig().app.url;
+  const url = configuredUrl ?? "http://analytics.local";
+  return {
+    id: ANALYTICS_APP_ID,
+    name: "Analytics",
+    url,
+    a2aUrl: url,
+  };
+}
+
+function localActionContext(
+  admin: AnalyticsAdminContext,
+  actionName: "list-feature-flags" | "set-feature-flag",
+  sourceContext?: ActionRunContext,
+) {
+  return {
+    ...sourceContext,
+    caller: sourceContext?.caller ?? ("http" as const),
+    userEmail: admin.userEmail,
+    orgId: admin.orgId,
+    appId: ANALYTICS_APP_ID,
+    actionName,
+  };
+}
+
+async function listLocalAnalyticsFeatureFlags(admin: AnalyticsAdminContext) {
+  return classifyWorkspaceFeatureFlagList(localAnalyticsApp(), {
+    status: 200,
+    body: await listLocalFeatureFlagsAction.run(
+      {},
+      localActionContext(admin, "list-feature-flags"),
+    ),
+  });
+}
+
+function unreachableLocalAnalyticsEntry(): FleetFlagApp {
+  const app = localAnalyticsApp();
+  return {
+    appId: app.id,
+    appName: app.name,
+    appOrigin: targetOrigin(app),
+    state: "unreachable",
+    flags: [],
+    reason: "target-execution",
+  };
+}
+
 async function delegatedToken(
   admin: AnalyticsAdminContext,
   origin: string,
@@ -298,6 +382,18 @@ function targetFailure(error: unknown): WorkspaceFeatureFlagFailure {
   return new WorkspaceFeatureFlagFailure(reason);
 }
 
+function localMutationFailure(error: unknown): WorkspaceFeatureFlagFailure {
+  const statusCode =
+    error && typeof error === "object" && "statusCode" in error
+      ? (error as { statusCode?: unknown }).statusCode
+      : undefined;
+  return new WorkspaceFeatureFlagFailure(
+    statusCode === 401 || statusCode === 403
+      ? "authorization"
+      : "target-action",
+  );
+}
+
 async function resolveTargetApp(
   admin: AnalyticsAdminContext,
   appId: string,
@@ -471,13 +567,20 @@ async function mapBounded<T, R>(
 export async function listWorkspaceFeatureFlags(
   admin: AnalyticsAdminContext,
 ): Promise<WorkspaceFeatureFlagsResult> {
-  const apps = await fetchOrgApps({
-    selfId: "analytics",
-    includeDirectoryApp: true,
-    serviceOrgId: admin.orgId,
-  });
-  if (apps.length === 0) return { directoryStatus: "unavailable", apps: [] };
-  const entries = await mapBounded(apps, async (app) => {
+  const [localEntry, directoryResult] = await Promise.all([
+    listLocalAnalyticsFeatureFlags(admin).catch(() =>
+      unreachableLocalAnalyticsEntry(),
+    ),
+    fetchOrgAppsResult({
+      selfId: ANALYTICS_APP_ID,
+      includeDirectoryApp: true,
+      serviceOrgId: admin.orgId,
+    }),
+  ]);
+  if (directoryResult.status === "unavailable")
+    return { directoryStatus: "unavailable", apps: [localEntry] };
+  const directoryApps = directoryResult.apps;
+  const entries = await mapBounded(directoryApps, async (app) => {
     try {
       return classifyWorkspaceFeatureFlagList(
         app,
@@ -494,13 +597,101 @@ export async function listWorkspaceFeatureFlags(
       };
     }
   });
-  return { directoryStatus: "available", apps: entries };
+  return { directoryStatus: "available", apps: [localEntry, ...entries] };
 }
 
 export async function setWorkspaceFeatureFlag(
   admin: AnalyticsAdminContext,
   input: WorkspaceFeatureFlagMutationInput,
+  sourceContext?: ActionRunContext,
 ): Promise<WorkspaceFeatureFlagMutationResult> {
+  if (input.appId === ANALYTICS_APP_ID) {
+    if (input.operation === "replace-rules" && !input.rules)
+      throw new WorkspaceFeatureFlagFailure("target-action");
+    const localRules = input.rules as
+      | {
+          mode: "off" | "on" | "rules";
+          emails?: string[];
+          orgIds?: string[];
+          percentage?: number;
+        }
+      | undefined;
+    const targetInput =
+      input.operation === "replace-rules"
+        ? {
+            operation: input.operation,
+            key: input.key,
+            rules: localRules!,
+          }
+        : { operation: input.operation, key: input.key };
+    let result;
+    try {
+      result = await setLocalFeatureFlagAction.run(
+        targetInput,
+        localActionContext(admin, "set-feature-flag", sourceContext),
+      );
+    } catch (error) {
+      throw localMutationFailure(error);
+    }
+    const orgDomain = result.scope.orgDomain ?? "";
+    let mutation: TargetFeatureFlagMutationResult;
+    try {
+      mutation = validateWorkspaceFeatureFlagMutation(
+        result,
+        mutationValidationExpectation(admin, input, orgDomain),
+      );
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("persistence");
+    }
+    let verifiedApp: FleetFlagApp;
+    try {
+      verifiedApp = await listLocalAnalyticsFeatureFlags(admin);
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    if (verifiedApp.state === "forbidden")
+      throw new WorkspaceFeatureFlagFailure("authorization");
+    const verifiedFlag = verifiedApp.flags.find(
+      (flag) => flag.key === input.key,
+    );
+    if (
+      verifiedApp.state !== "ready" ||
+      !verifiedFlag ||
+      typeof verifiedFlag.enabledForCurrentUser !== "boolean" ||
+      (input.operation === "enable-for-current-user" &&
+        !verifiedFlag.enabledForCurrentUser) ||
+      (input.operation === "off" && verifiedFlag.enabledForCurrentUser)
+    ) {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    try {
+      validateWorkspaceFeatureFlagMutation(
+        {
+          contractVersion: 2,
+          status: "ready",
+          key: input.key,
+          rules: verifiedFlag.rules,
+          scope: mutation.scope,
+        },
+        {
+          key: input.key,
+          orgDomain,
+          allowExplicitNoOrgTarget: true,
+          rules: mutation.rules,
+        },
+      );
+    } catch {
+      throw new WorkspaceFeatureFlagFailure("verification");
+    }
+    return {
+      contractVersion: 3,
+      status: "verified",
+      key: mutation.key,
+      rules: verifiedFlag.rules as Record<string, unknown>,
+      scope: mutation.scope,
+      enabledForCurrentUser: verifiedFlag.enabledForCurrentUser,
+    };
+  }
   const app = await resolveTargetApp(admin, input.appId);
   const targetInput = workspaceFeatureFlagTargetInput(input);
   let orgDomain: string | undefined;
@@ -533,30 +724,10 @@ export async function setWorkspaceFeatureFlag(
     throw new WorkspaceFeatureFlagFailure("target-action");
   let mutation: TargetFeatureFlagMutationResult;
   try {
-    mutation = validateWorkspaceFeatureFlagMutation(result.body, {
-      key: input.key,
-      orgDomain,
-      allowExplicitNoOrgTarget: true,
-      ...(input.operation === "replace-rules" && input.rules
-        ? {
-            rules: {
-              mode: input.rules.mode,
-              emails: input.rules.emails ?? [],
-              orgIds: input.rules.orgIds ?? [],
-              percentage: input.rules.percentage ?? 0,
-            },
-          }
-        : input.operation === "off"
-          ? {
-              rules: {
-                mode: "off",
-                emails: [],
-                orgIds: [],
-                percentage: 0,
-              },
-            }
-          : { enabledForEmail: admin.userEmail }),
-    });
+    mutation = validateWorkspaceFeatureFlagMutation(
+      result.body,
+      mutationValidationExpectation(admin, input, orgDomain),
+    );
   } catch {
     throw new WorkspaceFeatureFlagFailure("persistence");
   }
@@ -632,6 +803,7 @@ export async function getWorkspaceFlagTarget(
   admin: AnalyticsAdminContext,
   appId: string,
 ): Promise<FleetFlagApp> {
+  if (appId === ANALYTICS_APP_ID) return listLocalAnalyticsFeatureFlags(admin);
   const apps = await fetchOrgApps({
     selfId: "analytics",
     includeDirectoryApp: true,

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -5,6 +5,10 @@ import {
   loadActionsFromStaticRegistry,
   type AgentLoopFinalResponseGuardContext,
 } from "@agent-native/core/server";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
 
 import actionsRegistry from "../../.generated/actions-registry.js";
 import { INITIAL_TOOL_NAMES } from "../lib/agent-chat-plan-mode";
@@ -46,6 +50,139 @@ const ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
 // promptly instead of holding the dashboard composer for the 12-minute default.
 export const ANALYTICS_BACKGROUND_RUN_NO_PROGRESS_TIMEOUT_MS = 3 * 60_000;
 
+const DASHBOARD_EDIT_TOOLS = new Set([
+  "compose-dashboard",
+  "mutate-dashboard",
+  "rename-dashboard",
+  "reorder-dashboard-panels",
+  "restore-dashboard-revision",
+  "save-explorer-config",
+  "save-explorer-dashboard",
+  "save-sql-dashboard",
+  "update-dashboard",
+  "update-dashboard-demo",
+  "update-dashboard-summary",
+]);
+const ANALYSIS_EDIT_TOOLS = new Set([
+  "rename-analysis",
+  "restore-analysis-revision",
+  "save-analysis",
+]);
+
+function eventRecord(entry: unknown): Record<string, unknown> | undefined {
+  if (!entry || typeof entry !== "object") return undefined;
+  const event = (entry as { event?: unknown }).event;
+  return event && typeof event === "object"
+    ? (event as Record<string, unknown>)
+    : undefined;
+}
+
+function inputForCompletedTool(
+  events: readonly unknown[],
+  index: number,
+  completed: Record<string, unknown>,
+): Record<string, unknown> | undefined {
+  if (completed.input && typeof completed.input === "object") {
+    return completed.input as Record<string, unknown>;
+  }
+  const id = typeof completed.id === "string" ? completed.id : undefined;
+  for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+    const candidate = eventRecord(events[cursor]);
+    if (
+      candidate?.type !== "tool_start" ||
+      candidate.tool !== completed.tool ||
+      (id && candidate.id !== id)
+    ) {
+      continue;
+    }
+    return candidate.input && typeof candidate.input === "object"
+      ? (candidate.input as Record<string, unknown>)
+      : undefined;
+  }
+  return undefined;
+}
+
+function analyticsToolTarget(
+  tool: string,
+  input: Record<string, unknown> | undefined,
+  scopeType: "dashboard" | "analysis",
+): unknown {
+  if (scopeType === "dashboard") {
+    if (
+      tool === "compose-dashboard" ||
+      tool === "mutate-dashboard" ||
+      tool === "reorder-dashboard-panels" ||
+      tool === "update-dashboard" ||
+      tool === "update-dashboard-demo" ||
+      tool === "update-dashboard-summary"
+    ) {
+      return input?.dashboardId ?? input?.id;
+    }
+    return input?.id ?? input?.dashboardId;
+  }
+  return input?.analysisId ?? input?.id;
+}
+
+function hasAnalyticsEdit(
+  run: { events: readonly unknown[] },
+  tools: ReadonlySet<string>,
+  scopeType: "dashboard" | "analysis",
+  scopeId: string,
+): boolean {
+  return run.events.some((entry, index) => {
+    const record = eventRecord(entry);
+    if (!record) return false;
+    const input = inputForCompletedTool(run.events, index, record);
+    return (
+      record.type === "tool_done" &&
+      record.completedSideEffect === true &&
+      record.isError !== true &&
+      typeof record.tool === "string" &&
+      tools.has(record.tool) &&
+      analyticsToolTarget(record.tool, input, scopeType) === scopeId
+    );
+  });
+}
+
+async function autosaveAnalyticsAfterAgentTurn(
+  scope: { type: string; id: string },
+  run: {
+    events: readonly unknown[];
+    threadId?: string;
+    runId?: string;
+    turnId?: string;
+  },
+): Promise<void> {
+  const email = getRequestUserEmail();
+  if (!email) return;
+  const ctx = { email, orgId: getRequestOrgId() || null };
+  if (
+    scope.type === "dashboard" &&
+    hasAnalyticsEdit(run, DASHBOARD_EDIT_TOOLS, "dashboard", scope.id)
+  ) {
+    const { createDashboardRevisionSnapshot } =
+      await import("../lib/dashboards-store.js");
+    await createDashboardRevisionSnapshot(scope.id, ctx, {
+      ...(run.threadId ? { threadId: run.threadId } : {}),
+      ...(run.runId ? { runId: run.runId } : {}),
+      ...(run.turnId ? { turnId: run.turnId } : {}),
+    });
+    return;
+  }
+  if (
+    scope.type === "analysis" &&
+    hasAnalyticsEdit(run, ANALYSIS_EDIT_TOOLS, "analysis", scope.id)
+  ) {
+    const { createAnalysisRevisionSnapshot } =
+      await import("../lib/dashboards-store.js");
+    await createAnalysisRevisionSnapshot(scope.id, ctx, {
+      ...(run.threadId ? { threadId: run.threadId } : {}),
+      ...(run.runId ? { runId: run.runId } : {}),
+      ...(run.turnId ? { turnId: run.turnId } : {}),
+    });
+  }
+}
+
 const ANALYTICS_DATA_SOURCES_LINK = buildDeepLink({
   app: "analytics",
   view: "data-sources",
@@ -108,6 +245,7 @@ function hasPartialDashboardBuild(
 }
 
 export const BOUNDED_STRUCTURED_LOOKUP_GUIDANCE =
+  "TRUST SIGNALS: Prefer a current `dashboardCertified: true` saved panel; a `favorite: true` panel is a weaker relevance signal. " +
   "BOUNDED STRUCTURED LOOKUP FAST PATH — Treat existing analytics work like an engineer treats existing code: grep before writing. For an ordinary count, aggregate, grouped metric, trend, or record lookup, first call `search-analytics-query-catalog` once with focused metric/entity terms. It searches accessible dashboard names, chart titles/descriptions/saved queries, shipped dashboard patterns, and data-dictionary definitions together. Prefer the strongest approved dictionary or saved-chart match, preserve its source and business logic, adapt only the requested filters and explicit time window, then run one bounded query against that source. A user-named source wins, but still use a matching saved definition when it supplies the source's proven query shape. If there is no useful match, inspect the most likely source schema before asking a clarification about business meaning; do not ask the user to provide internal dataset, table, column, or SQL identifiers. Do not fan out across providers. Do not separately list every dashboard, call data-source status, browse the whole dictionary, load provider catalogs/corpus tools, or query a second source after a strong match. Once the query succeeds, answer immediately with its source, time window, filters, row count, and only necessary caveats. Do not enrich, cross-check, retry, or add breakdowns unless the user requested them, the first query failed, or its result conflicts with the known definition. The words `all`, `total`, or `exact` in a structured aggregate do not by themselves make it a corpus investigation. Never repeat an identical invalid or failed tool call; correct its arguments once or surface the error. This does not waive the real-data requirement: never answer from a guess, stale value, or unverified result. ";
 
 export const INTERNAL_PRODUCT_USAGE_GUIDANCE =
@@ -949,6 +1087,7 @@ export async function searchDashboardMentions(query: string, event?: any) {
 
 export default createAgentChatPlugin({
   appId: "analytics",
+  onAgentTurnComplete: autosaveAnalyticsAfterAgentTurn,
   // Resource prompt hydration performs additive schema checks. Keep that
   // work out of production serverless cold starts; it is not needed for the
   // dashboard's domain prompt and can contend with the request's DB queries.

package/corpus/templates/analytics/server/plugins/auth.ts

@@ -5,6 +5,7 @@ import {
 } from "@agent-native/core/server";
 
 const authPlugin = createAuthPlugin({
+  workspaceAppPublicPaths: ["/"],
   publicPaths: [
     "/track",
     "/api/analytics/track",

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

@@ -7,15 +7,16 @@ import { createCoreRoutesPlugin } from "@agent-native/core/server";
 // in Analytics" link produced by `update-dashboard` / `save-analysis` for a
 // connected Claude Code / Codex / Cowork never opened the record.
 export default createCoreRoutesPlugin({
+  googleOAuthManagedConnection: "not_applicable",
   extensionTools: true,
   resolveOpenPath: ({ view, params }) => {
     if (params.dashboardId) return `/dashboards/${params.dashboardId}`;
     if (params.analysisId) return `/analyses/${params.analysisId}`;
     if (view === "analyses") return "/dashboards";
     // `adhoc`/unknown with no id: there is no bare `/dashboards` record route —
-    // send to the app root rather than 404 (the polled `navigate` command
+    // send to the private app home rather than 404 (the polled `navigate` command
     // still applies any record focus once the SPA is loaded).
-    if (view === "adhoc") return "/";
+    if (view === "adhoc") return "/home";
     return null;
   },
 });

package/corpus/templates/analytics/server/plugins/db.ts

@@ -1832,6 +1832,17 @@ export const runAnalyticsMigrations = runMigrations(
         sqlite: "SELECT 1",
       },
     },
+    {
+      version: 148,
+      name: "analytics-dashboard-certification",
+      sql: "ALTER TABLE dashboards ADD COLUMN IF NOT EXISTS certification TEXT",
+    },
+    {
+      version: 149,
+      name: "analytics-revision-chat-context",
+      sql: `ALTER TABLE dashboard_revisions ADD COLUMN IF NOT EXISTS chat_context TEXT;
+ALTER TABLE analysis_revisions ADD COLUMN IF NOT EXISTS chat_context TEXT`,
+    },
   ],
   { table: "analytics_migrations" },
 );

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

@@ -68,6 +68,10 @@ is the target: a surface full of information and nearly empty of narration. So
 "make it minimal" is never satisfied by removing data or by burying it behind
 extra clicks, and never blocked by deleting a sentence.
 
+Keep on-screen text and badging minimal: show the shortest label needed for the
+next action, remove decorative or duplicate status chips, and put context in a
+tooltip or progressive disclosure when it is not needed to decide.
+
 Do not add, unless asked:
 
 - A page title that repeats the nav item or route the user just clicked, or a

package/corpus/templates/assets/.agents/skills/secrets/SKILL.md

@@ -31,6 +31,53 @@ standard workspace connections and org/workspace vault scopes; never put them
 in `.env` or deployment environment variables, and never add a provider-specific
 action or startup bootstrap just to write a credential for one organization.
 
+## Google OAuth triage
+
+| Observation | Meaning | Next action |
+| --- | --- | --- |
+| `invalid_grant` from a deliberately fake code | Google accepted the client pair and rejected only the code | Do not rotate credentials; check flow state and callback registration |
+| `invalid_client` | Google rejected the client id/secret pair | Verify the exact pair and deployment source before rotating |
+| `redirect_uri_mismatch` | The client, host, callback path, and Google registration disagree | Compare that exact tuple in Google Cloud Console; publish a new deploy if site-scoped or build-time configuration changes |
+
+Do not reason about this from memory. The probe checks both contracts: the
+unqualified `/health/google` endpoint reports the sign-in contract, while
+`/health/google?client=managed` reports deployment-level managed OAuth. It asks
+Google directly whether each live `(client_id, redirect_uri)` pair is
+registered:
+
+```bash
+pnpm check:google-redirect-uris -- --env all
+```
+
+The sign-in health path calls `checkGoogleSignInCredential()`, which prefers
+the active Better Auth pair and otherwise uses `resolveGoogleSignInCredentials()`
+from `packages/core/src/server/google-oauth-credentials.ts`. Managed health
+calls `checkGoogleManagedCredential()`, which resolves
+`["GOOGLE_CLIENT_ID", "GOOGLE_CLIENT_SECRET"]` through `resolveSecretPair()` in
+`packages/core/src/server/credential-provider.ts`. App provider handlers use
+`resolveGoogleProviderCredentialCandidatesWithReader()` with `resolveSecret`
+under request context. These are separate flows and can intentionally land on
+different Google clients, so a clean result for one says nothing about the
+other. Read both contracts before changing anything:
+
+```bash
+curl -s https://HOST/_agent-native/health/google | jq '{clientId,mismatchedPairs,credentialSource}'
+curl -s "https://HOST/_agent-native/health/google?client=managed" | jq '{clientId,mismatchedPairs,credentialSource}'
+```
+
+Different `clientId` values across those two, or `mismatchedPairs: true`, is a
+divergence to understand, not damage to undo. Never repair it by rotating a
+secret: writing a fresh value into whichever namespace the failing flow does
+not read verifies clean and changes nothing. Do not collapse the namespaces
+without first confirming which flow uses which client; separate sign-in and
+managed clients on one host can be deliberate. For prebuilt Netlify deploys,
+uploaded Functions read site-scoped secrets at runtime, and the health route
+resolves them per request. The build may receive masked placeholder values.
+After changing a site-scoped env var, publish a new deploy before verifying
+live behavior. Call it a rebuild when the changed value is baked into build
+output or static assets; a runtime-only secret does not need to be baked into
+the bundle.
+
 ## Credential Modeling Preflight
 
 Before registering a provider's fields, inspect the workspace/provider connection

package/corpus/templates/assets/app/components/layout/Header.tsx

@@ -8,7 +8,7 @@ import {
 import { useLocation } from "react-router";
 
 const pageTitleKeys: Record<string, string> = {
-  "/": "navigation.create",
+  "/home": "navigation.create",
   "/library": "navigation.library",
   "/brand-kits": "navigation.brandKits",
   "/agent": "settings.agentTitle",
@@ -49,7 +49,7 @@ export function Header() {
   const location = useLocation();
   const title = useHeaderTitle();
   const actions = useHeaderActions();
-  const showAgentToggle = location.pathname !== "/";
+  const showAgentToggle = location.pathname !== "/home";
 
   return (
     <header className="hidden h-12 shrink-0 items-center gap-3 border-b border-border bg-background px-4 md:flex lg:px-6">

package/corpus/templates/assets/app/components/layout/Layout.tsx

@@ -60,7 +60,7 @@ export function Layout({ children }: LayoutProps) {
   const imageModelMenu = useImageModelMenu();
   const [mobileSidebarOpen, setMobileSidebarOpen] = useState(false);
   const isCreateRoute =
-    location.pathname === "/" || location.pathname.startsWith("/chat/");
+    location.pathname === "/home" || location.pathname.startsWith("/chat/");
   const chatHomeHandoffActive = useAgentChatHomeHandoff({
     storageKey: ASSETS_CHAT_STORAGE_KEY,
     activePath: location.pathname,
@@ -71,7 +71,8 @@ export function Layout({ children }: LayoutProps) {
   );
   useAgentChatHomeHandoffLinks({
     storageKey: ASSETS_CHAT_STORAGE_KEY,
-    isChatPath: (pathname) => pathname === "/" || pathname.startsWith("/chat/"),
+    isChatPath: (pathname) =>
+      pathname === "/home" || pathname.startsWith("/chat/"),
     // Only preserve the transition when chat activity has recorded an active
     // handoff; an empty home chat should keep the destination sidebar closed.
     requireActiveHandoff: true,
@@ -151,7 +152,7 @@ export function Layout({ children }: LayoutProps) {
 
   function openCreateChatFullscreen() {
     focusAgentChat();
-    navigateWithAgentChatViewTransition(navigate, "/");
+    navigateWithAgentChatViewTransition(navigate, "/home");
   }
 
   return (