@kortix/ui 0.14.7 → 0.14.9

package/dist/internal/layout/project-nav-row.js

@@ -3,11 +3,12 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { HoverPrefetchLink } from '../components/hover-prefetch-link.js';
 import { SidebarMenuButton, SidebarMenuItem, useSidebar } from '../../primitives/sidebar.js';
 import { useIsMobile } from '../hooks/index.js';
+import { cn } from '../lib/utils.js';
 /** Keep the anchor's intent handlers and the caller's active-route semantics. */
-export function ProjectNavRow({ active, label, children, ...link }) {
+export function ProjectNavRow({ active, label, className, children, ...link }) {
     const isMobile = useIsMobile();
     const { setOpenMobile } = useSidebar();
-    return (_jsx(SidebarMenuItem, { children: _jsx(SidebarMenuButton, { asChild: true, isActive: active, tooltip: label, className: "group/menu-button text-sidebar-foreground relative", children: _jsx(HoverPrefetchLink, { ...link, onClick: (event) => {
+    return (_jsx(SidebarMenuItem, { children: _jsx(SidebarMenuButton, { asChild: true, isActive: active, tooltip: label, className: cn('group/menu-button text-sidebar-foreground relative', className), children: _jsx(HoverPrefetchLink, { ...link, onClick: (event) => {
                     link.onClick?.(event);
                     if (isMobile)
                         setOpenMobile(false);

package/dist/internal/layout/project-page-header.d.ts

@@ -5,12 +5,14 @@
  * same title-bar classes as the Customize tab bar (`CapabilityTabs`), so it
  * has the same height and clears the desktop window controls the same way.
  * A page has one view, so the title is plain text, not a one-tab underline
- * bar. `children` sit at the trailing edge (page actions, a docs link).
+ * bar. `titleAccessory` sits right after the title (a docs link). `children`
+ * sit at the trailing edge (page actions).
  *
  * The e2e journey `18-apps-ui` finds the page by the
  * `<h1>`.
  */
-export declare function ProjectPageHeader({ title, children, }: {
+export declare function ProjectPageHeader({ title, titleAccessory, children, }: {
     title: string;
+    titleAccessory?: React.ReactNode;
     children?: React.ReactNode;
 }): import("react").JSX.Element;

package/dist/internal/layout/project-page-header.js

@@ -8,12 +8,13 @@ import { SidebarToggle } from './sidebar-toggle.js';
  * same title-bar classes as the Customize tab bar (`CapabilityTabs`), so it
  * has the same height and clears the desktop window controls the same way.
  * A page has one view, so the title is plain text, not a one-tab underline
- * bar. `children` sit at the trailing edge (page actions, a docs link).
+ * bar. `titleAccessory` sits right after the title (a docs link). `children`
+ * sit at the trailing edge (page actions).
  *
  * The e2e journey `18-apps-ui` finds the page by the
  * `<h1>`.
  */
-export function ProjectPageHeader({ title, children, }) {
+export function ProjectPageHeader({ title, titleAccessory, children, }) {
     const sidebar = useOptionalSidebar();
-    return (_jsxs("div", { className: "kx-titlebar-row kx-capability-titlebar relative flex shrink-0 items-center gap-1 border-b px-2", "data-sidebar-collapsed": sidebar?.state === 'collapsed' || undefined, children: [_jsx(SidebarToggle, {}), _jsx("div", { className: "kx-titlebar-tabs flex h-10 min-w-0 flex-1 items-center px-3", children: _jsx("h1", { className: "text-foreground truncate text-sm font-medium", children: title }) }), children ? _jsx("div", { className: "flex shrink-0 items-center gap-1", children: children }) : null] }));
+    return (_jsxs("div", { className: "kx-titlebar-row kx-capability-titlebar relative flex shrink-0 items-center gap-1 border-b px-2", "data-sidebar-collapsed": sidebar?.state === 'collapsed' || undefined, children: [_jsx(SidebarToggle, {}), _jsxs("div", { className: "kx-titlebar-tabs flex h-10 min-w-0 flex-1 items-center gap-1.5 px-3", children: [_jsx("h1", { className: "text-foreground truncate text-sm font-medium", children: title }), titleAccessory] }), children ? _jsx("div", { className: "flex shrink-0 items-center gap-1", children: children }) : null] }));
 }

package/dist/internal/layout/project-settings-nav.js

@@ -7,11 +7,37 @@ export { CustomizeGlyph } from '../icons/customize.js';
 import { useTranslations } from '../../i18n/index.js';
 import { useUiPathname } from '../../providers/ui-provider.js';
 import { CountBadge } from '../../primitives/count-badge.js';
-import { activeCapabilityTab, capabilityTabHref, } from '../lib/capability-tab-routes.js';
+import { cn } from '../lib/utils.js';
+import { CAPABILITY_TABS, activeCapabilityTab, capabilityTabHref, } from '../lib/capability-tab-routes.js';
 import { PROJECT_ACTIONS } from '../lib/project-actions.js';
 import { useFeatureFlag } from '@kortix/sdk/react';
 import { useProjectPageCans } from '../lib/use-project-can.js';
 import { useReviewSessionSummary } from '../hooks/use-review-session-summary.js';
+import { HubLink } from '../account-hub/account-hub-location.js';
+import { hubTarget } from '../stores/account-panel-store.js';
+import { HoverPrefetchLink } from '../components/hover-prefetch-link.js';
+import { NavHoverCardContent, NavHoverCardList, useNavHoverCard } from './nav-hover-card.js';
+import { useLocalizedUiCatalog } from '../../i18n/ui-catalog/use-localized-ui-catalog.js';
+import { MENU_SEPARATOR, menuRow } from '../../primitives/menu-recipe.js';
+import { Popover, PopoverAnchor } from '../../primitives/popover.js';
+import { getProjectDetail } from '@kortix/sdk';
+import { contract, qk } from '@kortix/sdk/react';
+import { useQuery } from '@tanstack/react-query';
+import { AlarmIcon, CalendarIcon, CpuIcon, GearSixIcon, GitBranchIcon, LockKeyIcon, PlugIcon, RobotIcon, SquaresFourIcon, TrayIcon, UsersIcon, } from '@phosphor-icons/react';
+import { Fragment } from 'react';
+/** Each tab's glyph: the one the command palette shows for the same page (`menu-registry.ts`). */
+const TAB_ICONS = {
+    agent: RobotIcon,
+    skills: SquaresFourIcon,
+    connectors: PlugIcon,
+    triggers: AlarmIcon,
+    reminders: CalendarIcon,
+    models: CpuIcon,
+    secrets: LockKeyIcon,
+    files: GitBranchIcon,
+    review: TrayIcon,
+    config: GearSixIcon,
+};
 /**
  * The one project-configuration entry in the sidebar:
  * ProjectCustomizeNavItem, top of the panel under New session, navigating to
@@ -197,10 +223,41 @@ export function ProjectCustomizeNavItem({ projectId }) {
     // Connectors or one agent's page, not just on the landing tab.
     const isActive = !!pathname &&
         (pathname === customizePath(projectId) || activeCapabilityTab(pathname) !== null);
+    const card = useNavHoverCard({ enabled: !!tab && !!projectId });
     if (!tab)
         return null;
     // No project id means no valid href, so there is nothing to render.
     if (!projectId)
         return null;
-    return (_jsxs(ProjectNavRow, { active: isActive, label: t('customize'), href: capabilityTabHref(projectId, tab), prefetch: true, children: [_jsx("span", { className: "shrink-0", children: _jsx(CustomizeGlyph, {}) }), t('customize'), reviewCount > 0 ? (_jsx("span", { className: "ml-auto flex shrink-0 items-center gap-1", children: _jsx(CountBadge, { count: reviewCount, tone: "waiting" }) })) : null] }));
+    return (_jsxs(Popover, { open: card.open, onOpenChange: card.setOpen, children: [_jsx(PopoverAnchor, { virtualRef: card.anchorRef }), _jsxs(ProjectNavRow, { active: isActive, label: t('customize'), href: capabilityTabHref(projectId, tab), prefetch: true, ...card.rowProps, children: [_jsx("span", { className: "shrink-0", children: _jsx(CustomizeGlyph, {}) }), t('customize'), reviewCount > 0 ? (_jsx("span", { className: "ml-auto flex shrink-0 items-center gap-1", children: _jsx(CountBadge, { count: reviewCount, tone: "waiting" }) })) : null] }), _jsx(NavHoverCardContent, { ...card.contentProps, children: _jsx(CustomizeCardList, { projectId: projectId, tabs: access.tabs, reviewCount: reviewCount, onOpen: () => card.setOpen(false) }) })] }));
+}
+/**
+ * The Customize card: every tab the caller may open, in the tab bar's order
+ * and with its seams (Agents | the library | Members and Settings), so the
+ * card and the bar read as one list. Members is the bar's launcher into the
+ * Access hub, gated the same way (`project.members.read`).
+ */
+function CustomizeCardList({ projectId, tabs, reviewCount, onOpen, }) {
+    const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
+    const allTabs = useLocalizedUiCatalog(CAPABILITY_TABS);
+    const { data } = useQuery({
+        queryKey: qk.project.detail(projectId),
+        queryFn: () => getProjectDetail(projectId),
+        ...contract('config'),
+    });
+    const canReadMembers = useProjectPageCans(projectId)[PROJECT_ACTIONS.PROJECT_MEMBERS_READ]?.allowed === true;
+    const accountId = data?.project?.account_id;
+    const allowed = new Set(tabs);
+    const shown = allTabs.filter((entry) => allowed.has(entry.key));
+    const rowClass = menuRow('sm', 'default', 'cursor-pointer');
+    const tabRow = (entry) => {
+        const TabIcon = TAB_ICONS[entry.key];
+        return (_jsx("li", { children: _jsxs(HoverPrefetchLink, { href: capabilityTabHref(projectId, entry.key), onClick: onOpen, className: rowClass, children: [_jsx(TabIcon, { "aria-hidden": true }), _jsx("span", { className: "min-w-0 flex-1 truncate", children: entry.label }), entry.key === 'review' && reviewCount > 0 ? _jsx(CountBadge, { count: reviewCount, tone: "waiting" }) : null] }) }, entry.key));
+    };
+    const primary = shown.filter((entry) => entry.key === 'agent');
+    const library = shown.filter((entry) => entry.key !== 'agent' && entry.key !== 'config');
+    const trailing = shown.filter((entry) => entry.key === 'config');
+    const members = canReadMembers && accountId ? (_jsx("li", { children: _jsxs(HubLink, { to: hubTarget(accountId, { tab: 'access-projects', project: projectId }), onClick: onOpen, className: rowClass, children: [_jsx(UsersIcon, { "aria-hidden": true }), _jsx("span", { className: "min-w-0 flex-1 truncate", children: tI18nComplete.raw('text1044a4c056d0') })] }) }, "members")) : null;
+    const groups = [primary.map(tabRow), library.map(tabRow), [members, ...trailing.map(tabRow)].filter(Boolean)].filter((group) => group.length > 0);
+    return (_jsx(NavHoverCardList, { children: groups.map((group, index) => (_jsxs(Fragment, { children: [index > 0 ? _jsx("li", { "aria-hidden": true, className: cn(MENU_SEPARATOR, '-mx-1') }) : null, group] }, index))) }));
 }

package/dist/internal/lib/browser-error-noise.d.ts

@@ -4,7 +4,7 @@ export { isEmptyMessageUnresolvedBrowserChunkNoise, isStaleWebpackRuntimeCallNoi
 export { isClientRequestTimeoutMessage, isExpectedBillingGateMessage, isExpectedCompactionNoModelMessage, isGitMirrorUnavailableNoiseMessage, isModelNotServableNoise, isRuntimeNotReadyNoiseMessage, isServerDeadlineNoiseMessage, } from './browser-noise/rules/expected-states.js';
 export { isCaptchaInterceptorNoise, isExtensionRejectedObjectNoise, isExtensionSource, isInjectedAppSource, isInjectedScriptSendMessageNoise, isInpageJsNoErrorMessageNoise, isInpageWalletStreamNoise, isTronLinkProxyNoise, isUserscriptManagerNoise, } from './browser-noise/rules/extensions.js';
 export { isCanvasImageDataOOMNoise, isPaperShaderImageUniformNoise, isPaperShaderNullContextNoise, isPaperShaderWebGLUnsupportedNoise, isSpoofedWebGLGetParameterNoise, } from './browser-noise/rules/graphics.js';
-export { isOneTrustJsonParseNoise, isRedefineInjectedWalletNoise, isRedefineWebdriverNoise, isVercelLiveFeedbackNoise, } from './browser-noise/rules/injected-scripts.js';
+export { isGoogletagUndefinedNoise, isOneTrustJsonParseNoise, isRedefineInjectedWalletNoise, isRedefineWebdriverNoise, isVercelLiveFeedbackNoise, } from './browser-noise/rules/injected-scripts.js';
 export { isKnownBrowserNoiseMessage, isKnownTestNoiseMessage, } from './browser-noise/rules/messages.js';
 export { isConnectionClosedNoise, isFailedToSendMessageNoise, isFramelessNetworkErrorNoise, isSignalTimeoutNoise, } from './browser-noise/rules/network.js';
 export { isIosWebViewInjectedStackOverflowNoise, isOldBrowserDomNullDerefNoise, isFirefoxDeadObjectUnattributableNoise, isOldBrowserSyntaxParseError, isOldWebkitRegexNoiseMessage, isUndefinedVariableThirdPartyNoise, isUnresolvableStackOverflowNoise, } from './browser-noise/rules/old-browsers.js';

package/dist/internal/lib/browser-error-noise.js

@@ -29,7 +29,7 @@ export { isEmptyMessageUnresolvedBrowserChunkNoise, isStaleWebpackRuntimeCallNoi
 export { isClientRequestTimeoutMessage, isExpectedBillingGateMessage, isExpectedCompactionNoModelMessage, isGitMirrorUnavailableNoiseMessage, isModelNotServableNoise, isRuntimeNotReadyNoiseMessage, isServerDeadlineNoiseMessage, } from './browser-noise/rules/expected-states.js';
 export { isCaptchaInterceptorNoise, isExtensionRejectedObjectNoise, isExtensionSource, isInjectedAppSource, isInjectedScriptSendMessageNoise, isInpageJsNoErrorMessageNoise, isInpageWalletStreamNoise, isTronLinkProxyNoise, isUserscriptManagerNoise, } from './browser-noise/rules/extensions.js';
 export { isCanvasImageDataOOMNoise, isPaperShaderImageUniformNoise, isPaperShaderNullContextNoise, isPaperShaderWebGLUnsupportedNoise, isSpoofedWebGLGetParameterNoise, } from './browser-noise/rules/graphics.js';
-export { isOneTrustJsonParseNoise, isRedefineInjectedWalletNoise, isRedefineWebdriverNoise, isVercelLiveFeedbackNoise, } from './browser-noise/rules/injected-scripts.js';
+export { isGoogletagUndefinedNoise, isOneTrustJsonParseNoise, isRedefineInjectedWalletNoise, isRedefineWebdriverNoise, isVercelLiveFeedbackNoise, } from './browser-noise/rules/injected-scripts.js';
 export { isKnownBrowserNoiseMessage, isKnownTestNoiseMessage, } from './browser-noise/rules/messages.js';
 export { isConnectionClosedNoise, isFailedToSendMessageNoise, isFramelessNetworkErrorNoise, isSignalTimeoutNoise, } from './browser-noise/rules/network.js';
 export { isIosWebViewInjectedStackOverflowNoise, isOldBrowserDomNullDerefNoise, isFirefoxDeadObjectUnattributableNoise, isOldBrowserSyntaxParseError, isOldWebkitRegexNoiseMessage, isUndefinedVariableThirdPartyNoise, isUnresolvableStackOverflowNoise, } from './browser-noise/rules/old-browsers.js';

package/dist/internal/lib/browser-noise/rules/injected-scripts.d.ts

@@ -70,6 +70,13 @@ export declare function isInjectedWalletProviderWriteNoise(input: {
         filename?: unknown;
     } | undefined>;
 }): boolean;
+export declare function isGoogletagUndefinedNoise(input: {
+    message?: unknown;
+    filename?: unknown;
+    frames?: Array<{
+        filename?: unknown;
+    } | undefined>;
+}): boolean;
 /** Vercel toolbar frames have a reserved source path outside app bundles. */
 export declare function isVercelLiveFeedbackNoise(input: {
     filename?: unknown;

package/dist/internal/lib/browser-noise/rules/injected-scripts.js

@@ -213,6 +213,20 @@ export function isInjectedWalletProviderWriteNoise(input) {
     return (UNDEFINED_WALLET_PROVIDER_WRITE_MESSAGE.test(stripped) &&
         !sources.some((source) => isBrowserBundleSource(source) || isFirstPartyResolvedSource(source)));
 }
+/**
+ * A tag that calls Google Publisher Tag (`googletag`) before its library
+ * loads: `googletag is not defined` (V8, Gecko) or `Can't find variable:
+ * googletag` (WebKit). Better Stack, Kortix Frontend prod, 2026-10-27
+ * (KRTX-3549): 71 events in 2 s from one `<anonymous>` frame, 0 users. Kortix
+ * never loads or calls `googletag`; its Google Tag Manager writes only to
+ * `dataLayer`. A frame in our bundles or resolved first-party source keeps
+ * reporting.
+ */
+const GOOGLETAG_UNDEFINED_MESSAGE = /^(?:googletag is not defined|Can't find variable: googletag)$/;
+export function isGoogletagUndefinedNoise(input) {
+    return (GOOGLETAG_UNDEFINED_MESSAGE.test(stripErrorWrappers(normalizeString(input.message))) &&
+        !sourcesOf(input).some((source) => isBrowserBundleSource(source) || isFirstPartyResolvedSource(source)));
+}
 /** Vercel toolbar frames have a reserved source path outside app bundles. */
 export function isVercelLiveFeedbackNoise(input) {
     const sources = sourcesOf(input);
@@ -225,5 +239,6 @@ export const INJECTED_SCRIPT_RULES = [
     { id: 'redefine-webdriver', appliesTo: 'both', match: isRedefineWebdriverNoise },
     { id: 'redefine-wallet-provider', appliesTo: 'both', match: isRedefineInjectedWalletNoise },
     { id: 'wallet-provider-write', appliesTo: 'both', match: isInjectedWalletProviderWriteNoise },
+    { id: 'googletag-undefined', appliesTo: 'both', match: isGoogletagUndefinedNoise },
     { id: 'vercel-live-feedback', appliesTo: 'both', match: isVercelLiveFeedbackNoise },
 ];

package/dist/internal/lib/manifest-version.d.ts

@@ -3,7 +3,7 @@ export type ManifestVersion = 1 | 2 | 3;
 export declare function detectManifestVersion(manifestRaw: string | null | undefined): ManifestVersion;
 /** The manifest file a version lives in. An unresolved read (`null`) reads as v1. */
 export declare function manifestFilename(version: number | null): 'kortix.toml' | 'kortix.yaml';
-/** Only a v1 project is offered an upgrade (to v2). v3 is opt-in and not offered yet. `null` (not read yet) is not. */
+/** A v1 or v2 project is offered the upgrade to v3. `null` (not read yet) is not. */
 export declare function manifestNeedsUpgrade(version: ManifestVersion | null): boolean;
 export interface ProjectManifestVersionState {
     /** `null` while the project-detail fetch is still in flight — callers that

package/dist/internal/lib/manifest-version.js

@@ -27,9 +27,9 @@ export function detectManifestVersion(manifestRaw) {
 export function manifestFilename(version) {
     return (version ?? 1) >= 2 ? 'kortix.yaml' : 'kortix.toml';
 }
-/** Only a v1 project is offered an upgrade (to v2). v3 is opt-in and not offered yet. `null` (not read yet) is not. */
+/** A v1 or v2 project is offered the upgrade to v3. `null` (not read yet) is not. */
 export function manifestNeedsUpgrade(version) {
-    return version === 1;
+    return version === 1 || version === 2;
 }
 /**
  * Reads the SAME `qk.project.detail(id)` query the rest of Customize already

package/dist/internal/lib/memory-href.d.ts

@@ -0,0 +1,16 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+import type { ProjectMemoryLayerScope } from '@kortix/sdk';
+/** A memory layer as a link target: its scope and its key (`company` or the space id). */
+export interface MemoryLayerRef {
+    scope: ProjectMemoryLayerScope;
+    key: string;
+}
+/**
+ * Where a memory page opens: the Company Memory page, or its channel's or DM's
+ * Memory tab, with `?page=` (`&history=1` opens its History too). A channel or
+ * DM the reader is on keeps its other params, so an open thread stays beside
+ * the tab. Null when the host serves no such page or the space is not loaded.
+ */
+export declare function useMemoryPageHref(projectId: string | null | undefined, enabled?: boolean): (layer: MemoryLayerRef, pageId: string, options?: {
+    history?: boolean;
+}) => string | null;

package/dist/internal/lib/memory-href.js

@@ -0,0 +1,46 @@
+'use client';
+import { useProjectSpaces } from '@kortix/sdk/react';
+import { useCallback } from 'react';
+import { uiRoutes } from '../../lib/routes.js';
+import { useUiPathname, useUiSearchParams } from '../../providers/ui-provider.js';
+/**
+ * Where a memory page opens: the Company Memory page, or its channel's or DM's
+ * Memory tab, with `?page=` (`&history=1` opens its History too). A channel or
+ * DM the reader is on keeps its other params, so an open thread stays beside
+ * the tab. Null when the host serves no such page or the space is not loaded.
+ */
+export function useMemoryPageHref(projectId, enabled = true) {
+    const pathname = useUiPathname();
+    const searchParams = useUiSearchParams();
+    const spaces = useProjectSpaces(projectId, { enabled }).data;
+    return useCallback((layer, pageId, options) => {
+        if (!projectId)
+            return null;
+        if (layer.scope === 'company') {
+            const memory = uiRoutes().memory(projectId);
+            if (!memory)
+                return null;
+            const params = new URLSearchParams({ page: pageId });
+            if (options?.history)
+                params.set('history', '1');
+            return `${memory}?${params.toString()}`;
+        }
+        const space = spaces?.find((candidate) => candidate.space_id === layer.key);
+        let path = null;
+        if (space?.kind === 'channel' && space.slug)
+            path = uiRoutes().channel(projectId, space.slug);
+        else if (space?.kind === 'dm' && space.dm_agent_name)
+            path = uiRoutes().dm(projectId, space.dm_agent_name);
+        if (!path)
+            return null;
+        const here = pathname === path || !!pathname?.endsWith(path);
+        const params = new URLSearchParams(here ? searchParams.toString() : '');
+        params.set('tab', 'memory');
+        params.set('page', pageId);
+        if (options?.history)
+            params.set('history', '1');
+        else
+            params.delete('history');
+        return `${here ? pathname : path}?${params.toString()}`;
+    }, [projectId, pathname, searchParams, spaces]);
+}

package/dist/internal/lib/pixel-mark.d.ts

@@ -0,0 +1,33 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * An agent's pixel mark: a 7×7 mirrored pixel figure derived from its slug.
+ *
+ * Same slug, same mark, on every surface and every device. Nothing is stored:
+ * the slug is hashed (FNV-1a), the hash seeds a PRNG (mulberry32), the PRNG
+ * fills the left half of the grid against a density mask, and the half is
+ * mirrored. A draw that fails the quality gate is redrawn from a salted seed,
+ * so retries stay deterministic. The tone comes from a second hash.
+ *
+ * Changing SIZE, MASK, the gate or PALETTES changes every agent's mark — the
+ * golden test in `pixel-mark.test.ts` exists to make that a deliberate act.
+ */
+export declare const PIXEL_MARK_SIZE = 7;
+export interface PixelMarkTone {
+    name: string;
+    tile: string;
+    ink: string;
+    /** Dark theme: the pair inverts, so the tile stays visible on a dark page. */
+    tileDark: string;
+    inkDark: string;
+}
+export declare const PIXEL_MARK_TONES: readonly PixelMarkTone[];
+type Grid = boolean[][];
+export declare function fnv1a(input: string): number;
+/** Readable at 14px, fills the frame, one connected body. */
+export declare function passesPixelMarkGate(grid: Grid): boolean;
+export declare function pixelMark(slug: string): {
+    grid: Grid;
+    path: string;
+    tone: PixelMarkTone;
+};
+export {};

package/dist/internal/lib/pixel-mark.js

@@ -0,0 +1,152 @@
+/**
+ * An agent's pixel mark: a 7×7 mirrored pixel figure derived from its slug.
+ *
+ * Same slug, same mark, on every surface and every device. Nothing is stored:
+ * the slug is hashed (FNV-1a), the hash seeds a PRNG (mulberry32), the PRNG
+ * fills the left half of the grid against a density mask, and the half is
+ * mirrored. A draw that fails the quality gate is redrawn from a salted seed,
+ * so retries stay deterministic. The tone comes from a second hash.
+ *
+ * Changing SIZE, MASK, the gate or PALETTES changes every agent's mark — the
+ * golden test in `pixel-mark.test.ts` exists to make that a deliberate act.
+ */
+export const PIXEL_MARK_SIZE = 7;
+const HALF = 4;
+const MAX_ATTEMPTS = 256;
+// Fill chance per cell, outer edge → spine. Dense centre, sparse edges, so the
+// mirrored result reads as one body.
+const MASK = [
+    [0.15, 0.3, 0.45, 0.55],
+    [0.3, 0.5, 0.6, 0.7],
+    [0.4, 0.6, 0.65, 0.7],
+    [0.5, 0.65, 0.7, 0.75],
+    [0.4, 0.55, 0.6, 0.65],
+    [0.3, 0.45, 0.5, 0.5],
+    [0.2, 0.35, 0.4, 0.35],
+];
+const tone = (name, tile, ink) => ({
+    name,
+    tile,
+    ink,
+    tileDark: ink,
+    inkDark: tile,
+});
+export const PIXEL_MARK_TONES = [
+    tone('graphite', '#EDEDED', '#191919'),
+    tone('sand', '#F1EBDD', '#6B5A3A'),
+    tone('moss', '#E6EDE0', '#3F5A33'),
+    tone('sea', '#E2ECF0', '#2E5566'),
+    tone('blue', '#E6EEFF', '#2457C5'),
+    tone('plum', '#EEE6F0', '#5E3A68'),
+    tone('clay', '#F3E6E0', '#7A4532'),
+    tone('slate', '#E4E7EC', '#3B4656'),
+];
+/** The built-in agent and the platform's Meta agent keep the brand tile. */
+const BRAND = {
+    name: 'brand',
+    tile: '#1F1F1F',
+    ink: '#FFFFFF',
+    tileDark: '#2C2C2C',
+    inkDark: '#FFFFFF',
+};
+const RESERVED = { kortix: BRAND, meta: BRAND };
+export function fnv1a(input) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return h >>> 0;
+}
+function mulberry32(seed) {
+    let a = seed;
+    return () => {
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function draw(seed) {
+    const rand = mulberry32(seed);
+    return MASK.map((row) => {
+        const half = row.map((p) => rand() < p);
+        return [...half, half[2], half[1], half[0]];
+    });
+}
+function largestComponent(grid) {
+    const seen = grid.map((row) => row.map(() => false));
+    let best = 0;
+    for (let r = 0; r < PIXEL_MARK_SIZE; r++)
+        for (let c = 0; c < PIXEL_MARK_SIZE; c++) {
+            if (!grid[r][c] || seen[r][c])
+                continue;
+            let size = 0;
+            const stack = [[r, c]];
+            seen[r][c] = true;
+            while (stack.length) {
+                const [y, x] = stack.pop();
+                size++;
+                for (const [ny, nx] of [[y + 1, x], [y - 1, x], [y, x + 1], [y, x - 1]]) {
+                    if (grid[ny]?.[nx] && !seen[ny][nx]) {
+                        seen[ny][nx] = true;
+                        stack.push([ny, nx]);
+                    }
+                }
+            }
+            best = Math.max(best, size);
+        }
+    return best;
+}
+function hasIsolatedPixel(grid) {
+    return grid.some((row, r) => row.some((on, c) => {
+        if (!on)
+            return false;
+        for (let dy = -1; dy <= 1; dy++)
+            for (let dx = -1; dx <= 1; dx++)
+                if ((dy || dx) && grid[r + dy]?.[c + dx])
+                    return false;
+        return true;
+    }));
+}
+/** Readable at 14px, fills the frame, one connected body. */
+export function passesPixelMarkGate(grid) {
+    const filled = grid.flat().filter(Boolean).length;
+    if (filled < 18 || filled > 30)
+        return false;
+    const rows = grid.filter((row) => row.some(Boolean)).length;
+    const cols = grid[0].filter((_, c) => grid.some((row) => row[c])).length;
+    if (rows < 5 || cols < 5)
+        return false;
+    if (grid.filter((row) => row.every(Boolean)).length > 1)
+        return false;
+    if (grid.filter((row) => row[HALF - 1]).length < 3)
+        return false;
+    if (hasIsolatedPixel(grid))
+        return false;
+    return largestComponent(grid) >= Math.ceil(filled * 0.85);
+}
+/** One SVG path, horizontal runs merged. Render in `viewBox="0 0 7 7"`. */
+function toPath(grid) {
+    let d = '';
+    grid.forEach((row, y) => {
+        for (let x = 0; x < PIXEL_MARK_SIZE;) {
+            if (!row[x]) {
+                x++;
+                continue;
+            }
+            const start = x;
+            while (x < PIXEL_MARK_SIZE && row[x])
+                x++;
+            d += `M${start} ${y}h${x - start}v1h-${x - start}z`;
+        }
+    });
+    return d;
+}
+export function pixelMark(slug) {
+    let grid = draw(fnv1a(slug));
+    for (let attempt = 1; !passesPixelMarkGate(grid) && attempt < MAX_ATTEMPTS; attempt++)
+        grid = draw(fnv1a(`${slug}:${attempt}`));
+    const tone = RESERVED[slug] ?? PIXEL_MARK_TONES[fnv1a(`${slug}#tone`) % PIXEL_MARK_TONES.length];
+    return { grid, path: toPath(grid), tone };
+}

package/dist/internal/lib/use-project-feature-flags.js

@@ -22,15 +22,11 @@ import { useFeatureFlag } from '@kortix/sdk/react';
  */
 export function useProjectFeatureFlags(projectId) {
     const marketplace = useFeatureFlag(projectId, 'marketplace');
-    const connectorsApiDiscover = useFeatureFlag(projectId, 'connectors_api_discover');
-    const agentmailEmail = useFeatureFlag(projectId, 'agentmail_email');
     const metaAgent = useFeatureFlag(projectId, 'meta_agent');
-    const monitors = useFeatureFlag(projectId, 'monitors');
     const reminders = useFeatureFlag(projectId, 'reminders');
     const warmSessions = useFeatureFlag(projectId, 'warm_sessions');
     const secretsEgress = useFeatureFlag(projectId, 'secrets_egress');
     const pooledProviderSecrets = useFeatureFlag(projectId, 'pooled_provider_secrets');
-    const piHarness = useFeatureFlag(projectId, 'pi_harness');
     const genui = useFeatureFlag(projectId, 'genui');
     const usRegion = useFeatureFlag(projectId, 'us_region');
     const eventTriggers = useFeatureFlag(projectId, 'event_triggers');
@@ -39,21 +35,21 @@ export function useProjectFeatureFlags(projectId) {
     const drives = useFeatureFlag(projectId, 'drives');
     const sessionLog = useFeatureFlag(projectId, 'session_log');
     const sessionLogRestore = useFeatureFlag(projectId, 'session_log_restore');
-    const connectorsV2 = useFeatureFlag(projectId, 'connectors_v2');
+    const projectChannels = useFeatureFlag(projectId, 'project_channels');
     const agentRooms = useFeatureFlag(projectId, 'agent_rooms');
     const goals = useFeatureFlag(projectId, 'goals');
+    const artifacts = useFeatureFlag(projectId, 'artifacts');
+    const emailChannel = useFeatureFlag(projectId, 'email_channel');
+    const workspaceVolume = useFeatureFlag(projectId, 'workspace_volume');
+    const sessionGroups = useFeatureFlag(projectId, 'session_groups');
     return {
         flags: {
             marketplace: marketplace.enabled,
-            connectors_api_discover: connectorsApiDiscover.enabled,
-            agentmail_email: agentmailEmail.enabled,
             meta_agent: metaAgent.enabled,
-            monitors: monitors.enabled,
             reminders: reminders.enabled,
             warm_sessions: warmSessions.enabled,
             secrets_egress: secretsEgress.enabled,
             pooled_provider_secrets: pooledProviderSecrets.enabled,
-            pi_harness: piHarness.enabled,
             genui: genui.enabled,
             us_region: usRegion.enabled,
             event_triggers: eventTriggers.enabled,
@@ -62,11 +58,15 @@ export function useProjectFeatureFlags(projectId) {
             drives: drives.enabled,
             session_log: sessionLog.enabled,
             session_log_restore: sessionLogRestore.enabled,
-            connectors_v2: connectorsV2.enabled,
+            project_channels: projectChannels.enabled,
             agent_rooms: agentRooms.enabled,
             goals: goals.enabled,
+            artifacts: artifacts.enabled,
+            email_channel: emailChannel.enabled,
+            workspace_volume: workspaceVolume.enabled,
+            session_groups: sessionGroups.enabled,
         },
         // The trailing hook's loading state — keep this on the LAST hook above.
-        isLoading: goals.isLoading,
+        isLoading: sessionGroups.isLoading,
     };
 }

package/dist/internal/lib/utils/heic-convert.d.ts

@@ -1,7 +1,7 @@
 /** @internal Kortix apps only. No semver: it may change in any release. */
 /**
  * HEIC/HEIF → JPEG conversion.
- * heic2any is lazy-loaded — zero bundle cost when no HEIC files are opened.
+ * The CSP-safe decoder is lazy-loaded; production never permits unsafe-eval.
  */
 export declare function isHeicFile(filename: string): boolean;
 export declare function convertHeicBlobToJpeg(blob: Blob): Promise<Blob>;

package/dist/internal/lib/utils/heic-convert.js

@@ -1,13 +1,12 @@
 /**
  * HEIC/HEIF → JPEG conversion.
- * heic2any is lazy-loaded — zero bundle cost when no HEIC files are opened.
+ * The CSP-safe decoder is lazy-loaded; production never permits unsafe-eval.
  */
 const HEIC_EXT = new Set(['heic', 'heif']);
 export function isHeicFile(filename) {
     return HEIC_EXT.has(filename.split('.').pop()?.toLowerCase() || '');
 }
 export async function convertHeicBlobToJpeg(blob) {
-    const heic2any = (await import('heic2any')).default;
-    const result = await heic2any({ blob, toType: 'image/jpeg', quality: 0.92 });
-    return Array.isArray(result) ? result[0] : result;
+    const { heicTo } = await import('heic-to/csp');
+    return heicTo({ blob, type: 'image/jpeg', quality: 0.92 });
 }

package/dist/internal/lib/web-notifications.d.ts

@@ -2,6 +2,7 @@
 import type { UiTranslator } from '../../i18n/index.js';
 import { type TurnCompleteMsg } from './turn-broadcast.js';
 import { type NotificationPreferences } from '@kortix/sdk';
+import type { QueryClient } from '@tanstack/react-query';
 /** The push `type` of each inbox kind (`pushTypeOf` in `@kortix/shared/notification-kinds`). */
 export type WebNotificationType = 'completion' | 'error' | 'question' | 'permission' | 'shared' | 'automation_failed' | 'automation_recovered' | 'capture_device_down' | 'capture_device_recovered' | 'message';
 export interface WebNotificationPayload {
@@ -36,6 +37,11 @@ export interface WebNotificationPayload {
     preview?: string;
     /** Localized "Open session" for the finished-turn toast. */
     openSessionLabel?: string;
+    /**
+     * Set when the turn ended while a channel or DM page was on screen: its
+     * thread opens in that page's panel (`?thread=`), not on the session page.
+     */
+    threadHref?: string;
     /** The open change request the finished turn produced: the toast offers Review. */
     changeRequest?: {
         crId: string;
@@ -59,6 +65,20 @@ export declare function setServerPushPreferences(kinds: NotificationPreferences[
  * via Cmd+Tab / Alt+Tab (`!document.hasFocus()`).
  */
 export declare function isTabHidden(): boolean;
+/**
+ * A finished turn opens in the thread panel of the channel or DM page on
+ * screen (`?thread=<id>`) only when it is one of that space's threads: the
+ * path's project is the session's, and the cached thread list of the space
+ * holds the session. Null otherwise, so any other session keeps its session
+ * page. Reads the query cache; never fetches.
+ */
+export declare function spacesThreadHref(location: {
+    pathname: string;
+    search: string;
+}, session: {
+    sessionId: string;
+    projectId: string | null | undefined;
+}, cache: QueryClient): string | null;
 /**
  * Check if the user is currently viewing a specific session.
  * Checks the tab store (dashboard session tabs) and the current URL