@kortix/ui 0.14.6 → 0.14.8

package/dist/internal/goals/goal-meta.d.ts

@@ -0,0 +1,30 @@
+/** @internal Kortix apps only. No semver: it may change in any release. */
+/**
+ * The shared vocabulary of the Goals surfaces (flag `goals`): the status chip,
+ * the health line, progress and "needs you". The Goals page, the sidebar row
+ * and the session header chip all read a goal through these, so a status or a
+ * health issue reads the same everywhere.
+ */
+import type { ProjectGoal, ProjectGoalDocument, ProjectGoalIssue, ProjectGoalItem, ProjectGoalStatus } from '@kortix/sdk';
+export declare function GoalStatusBadge({ status }: {
+    status: ProjectGoalStatus | null | undefined;
+}): import("react").JSX.Element | null;
+/** Green: running. Orange: needs attention. Grey: closed. */
+export declare function GoalHealthDot({ goal }: {
+    goal: Pick<ProjectGoal, 'health'>;
+}): import("react").JSX.Element;
+/** One sentence per issue, for the health line and its tooltip. */
+export declare function useGoalIssueText(): (issue: ProjectGoalIssue, goal: Pick<ProjectGoal, "heartbeat">) => string;
+export declare function goalProgress(goal: ProjectGoalDocument | null): {
+    met: number;
+    total: number;
+};
+/** Open asks for a person (not the agent): what the goal waits on someone for. */
+export declare function goalOpenAsks(goal: ProjectGoalDocument | null): ProjectGoalItem[];
+/** The goal needs a person: an open ask, or a health issue. */
+export declare function goalNeedsYou(goal: ProjectGoal): boolean;
+/** "in 33 min", "2 hr ago", "Tue 09:00": the reminders time format. */
+export declare function formatGoalTime(iso: string | null | undefined, locale: string, now: number): string;
+export declare function goalHref(projectId: string, goal: Pick<ProjectGoal, 'scope' | 'slug'>): string | null;
+/** The current time, re-read every 30 seconds: relative times and health stay current. */
+export { useNow as useGoalClock } from '../reminders/use-refetch-after-fire.js';

package/dist/internal/goals/goal-meta.js

@@ -0,0 +1,55 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { formatFireTime } from '../reminders/reminder-format.js';
+import { useTranslations } from '../../i18n/index.js';
+import { StatusBadge, StatusDot } from '../../primitives/status.js';
+import { uiRoutes } from '../../lib/routes.js';
+const STATUS_TONE = {
+    draft: 'neutral',
+    active: 'info',
+    waiting_on_user: 'warning',
+    waiting_external: 'neutral',
+    verifying: 'info',
+    done: 'success',
+    abandoned: 'neutral',
+};
+export function GoalStatusBadge({ status }) {
+    const t = useTranslations('goals');
+    if (!status)
+        return null;
+    return _jsx(StatusBadge, { tone: STATUS_TONE[status] ?? 'neutral', children: t(`status.${status}`) });
+}
+/** Green: running. Orange: needs attention. Grey: closed. */
+export function GoalHealthDot({ goal }) {
+    const tone = goal.health.state === 'healthy' ? 'success' : goal.health.state === 'attention' ? 'warning' : 'neutral';
+    return _jsx(StatusDot, { tone: tone });
+}
+/** One sentence per issue, for the health line and its tooltip. */
+export function useGoalIssueText() {
+    const t = useTranslations('goals');
+    return (issue, goal) => issue === 'heartbeat_failed'
+        ? t('issue.heartbeat_failed', { error: goal.heartbeat?.last_error ?? '—' })
+        : t(`issue.${issue}`);
+}
+export function goalProgress(goal) {
+    const criteria = goal?.success_criteria ?? [];
+    return { met: criteria.filter((c) => c.met).length, total: criteria.length };
+}
+/** Open asks for a person (not the agent): what the goal waits on someone for. */
+export function goalOpenAsks(goal) {
+    return (goal?.items ?? []).filter((i) => i.kind === 'ask' && i.status === 'open' && i.owner !== 'agent');
+}
+/** The goal needs a person: an open ask, or a health issue. */
+export function goalNeedsYou(goal) {
+    return goal.health.state === 'attention' || (goal.health.state !== 'closed' && goalOpenAsks(goal.goal).length > 0);
+}
+/** "in 33 min", "2 hr ago", "Tue 09:00": the reminders time format. */
+export function formatGoalTime(iso, locale, now) {
+    return iso ? formatFireTime(iso, locale, now) : '—';
+}
+export function goalHref(projectId, goal) {
+    const list = uiRoutes().goals(projectId);
+    return list ? `${list}/${goal.scope}/${encodeURIComponent(goal.slug)}` : null;
+}
+/** The current time, re-read every 30 seconds: relative times and health stay current. */
+export { useNow as useGoalClock } from '../reminders/use-refetch-after-fire.js';

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/query-client-singleton.d.ts

@@ -3,7 +3,13 @@ import type { QueryClient } from '@tanstack/react-query';
 export declare function registerQueryClient(client: QueryClient): void;
 export declare function getSharedQueryClient(): QueryClient | null;
 /**
- * Run `run` with the shared client — now if it is registered, else as soon as
- * it registers. A one-shot: it fires once and is forgotten.
+ * Run `run` with the shared client now (if one is registered), and again with
+ * every DIFFERENT client registered later. Returns the unsubscribe.
+ *
+ * AuthProvider sits ABOVE ReactQueryProvider, and #10344 mounts the app shell
+ * one auth round trip sooner, so a caller can ask before any client exists.
+ * `ReactQueryProvider` registers during render, and React can discard that
+ * render (a hydration retry, a suspension, Strict Mode) and commit a second
+ * client: a caller that ran once would hold a client the app no longer reads.
  */
-export declare function whenQueryClientReady(run: (client: QueryClient) => void): void;
+export declare function onEachQueryClient(run: (client: QueryClient) => void): () => void;

package/dist/internal/lib/query-client-singleton.js

@@ -8,27 +8,33 @@
  * from the central reset helper.
  */
 let sharedQueryClient = null;
-let waiters = [];
+/** `onEachQueryClient` subscribers. replica-local: one tab's app. */
+const followers = new Set();
 export function registerQueryClient(client) {
+    if (sharedQueryClient === client)
+        return;
     sharedQueryClient = client;
-    // AuthProvider sits ABOVE ReactQueryProvider, and #10344 mounts the app
-    // shell one auth round trip sooner, so `adoptDeviceCaches` can run before
-    // this registers. Flush anyone who asked for the client before it existed.
-    const pending = waiters;
-    waiters = [];
-    for (const run of pending)
+    for (const run of [...followers])
         run(client);
 }
 export function getSharedQueryClient() {
     return sharedQueryClient;
 }
 /**
- * Run `run` with the shared client — now if it is registered, else as soon as
- * it registers. A one-shot: it fires once and is forgotten.
+ * Run `run` with the shared client now (if one is registered), and again with
+ * every DIFFERENT client registered later. Returns the unsubscribe.
+ *
+ * AuthProvider sits ABOVE ReactQueryProvider, and #10344 mounts the app shell
+ * one auth round trip sooner, so a caller can ask before any client exists.
+ * `ReactQueryProvider` registers during render, and React can discard that
+ * render (a hydration retry, a suspension, Strict Mode) and commit a second
+ * client: a caller that ran once would hold a client the app no longer reads.
  */
-export function whenQueryClientReady(run) {
+export function onEachQueryClient(run) {
+    followers.add(run);
     if (sharedQueryClient)
         run(sharedQueryClient);
-    else
-        waiters.push(run);
+    return () => {
+        followers.delete(run);
+    };
 }

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

@@ -30,7 +30,6 @@ export function useProjectFeatureFlags(projectId) {
     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');
@@ -42,6 +41,7 @@ export function useProjectFeatureFlags(projectId) {
     const connectorsV2 = useFeatureFlag(projectId, 'connectors_v2');
     const agentRooms = useFeatureFlag(projectId, 'agent_rooms');
     const goals = useFeatureFlag(projectId, 'goals');
+    const workspaceVolume = useFeatureFlag(projectId, 'workspace_volume');
     return {
         flags: {
             marketplace: marketplace.enabled,
@@ -53,7 +53,6 @@ export function useProjectFeatureFlags(projectId) {
             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,
@@ -65,8 +64,9 @@ export function useProjectFeatureFlags(projectId) {
             connectors_v2: connectorsV2.enabled,
             agent_rooms: agentRooms.enabled,
             goals: goals.enabled,
+            workspace_volume: workspaceVolume.enabled,
         },
         // The trailing hook's loading state — keep this on the LAST hook above.
-        isLoading: goals.isLoading,
+        isLoading: workspaceVolume.isLoading,
     };
 }

package/dist/internal/share/session-shares-modal.js

@@ -16,13 +16,13 @@ import { isShareLive, publicShareUrl, shareListState, useRevokePublicShare, useS
 import { cn } from '../../lib/utils.js';
 function ShareRow({ share, onRevoke, isRevoking, }) {
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
-    const tTranscript = useTranslations('hardcodedUi.publicTranscriptShare');
     const [copied, setCopied] = useState(false);
     const live = isShareLive(share);
     // Read at render time: `publicShareUrl` is null outside a browser (SSR).
     const url = publicShareUrl(share.public_path);
     const isFile = share.resource_type === 'file';
-    // A transcript share has no port and no file: it names the conversation.
+    // A legacy transcript share (revoked; the feature is removed) still carries
+    // no port and no file: its label is the row's own meta.
     const isTranscript = share.resource_type === 'transcript';
     const Icon = isFile ? FileText : isTranscript ? ChatText : Globe;
     const copy = async () => {
@@ -33,11 +33,7 @@ function ShareRow({ share, onRevoke, isRevoking, }) {
         successToast(tI18nComplete.raw('textd0f24de8dbc6'));
         setTimeout(() => setCopied(false), 2000);
     };
-    return (_jsxs("li", { className: cn('group bg-popover flex items-center gap-3 rounded-md border px-4 py-2.5 transition-colors', !live && 'opacity-60'), children: [_jsx("span", { className: cn('flex size-9 shrink-0 items-center justify-center rounded-sm', live ? 'bg-kortix-green/15' : 'bg-muted'), children: _jsx(Icon, { className: cn('size-5', live ? 'text-kortix-green' : 'text-muted-foreground') }) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex items-center gap-1.5", children: [_jsx("span", { className: "truncate text-sm font-medium", children: share.label }), !live && (_jsx(Badge, { variant: "outline", size: "xs", children: share.revoked_at ? 'Revoked' : 'Expired' }))] }), _jsx("p", { className: "text-muted-foreground truncate text-xs", children: isFile
-                            ? share.file_path
-                            : isTranscript
-                                ? tTranscript('rowMeta')
-                                : `Port ${share.port}${share.path}` })] }), live && (_jsxs("span", { className: "flex shrink-0 items-center gap-1", children: [_jsx(Hint, { label: copied ? 'Copied' : tI18nComplete.raw('textdbf362d4f210'), side: "bottom", children: _jsx(Button, { variant: "ghost", size: "icon", "aria-label": tI18nComplete.raw('textdbf362d4f210'), disabled: !url, onClick: () => void copy(), className: "size-8 active:scale-[0.96]", children: copied ? (_jsx(Check, { className: "text-kortix-green size-4" })) : (_jsx(Link2, { className: "size-4" })) }) }), _jsxs(Button, { variant: "ghost", size: "sm", onClick: onRevoke, disabled: isRevoking, children: [isRevoking ? _jsx(Loading, { className: "size-4 shrink-0" }) : null, tI18nComplete.raw('text87e6d00bbf53')] })] }))] }));
+    return (_jsxs("li", { className: cn('group bg-popover flex items-center gap-3 rounded-md border px-4 py-2.5 transition-colors', !live && 'opacity-60'), children: [_jsx("span", { className: cn('flex size-9 shrink-0 items-center justify-center rounded-sm', live ? 'bg-kortix-green/15' : 'bg-muted'), children: _jsx(Icon, { className: cn('size-5', live ? 'text-kortix-green' : 'text-muted-foreground') }) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex items-center gap-1.5", children: [_jsx("span", { className: "truncate text-sm font-medium", children: share.label }), !live && (_jsx(Badge, { variant: "outline", size: "xs", children: share.revoked_at ? 'Revoked' : 'Expired' }))] }), _jsx("p", { className: "text-muted-foreground truncate text-xs", children: isFile ? share.file_path : isTranscript ? share.label : `Port ${share.port}${share.path}` })] }), live && (_jsxs("span", { className: "flex shrink-0 items-center gap-1", children: [_jsx(Hint, { label: copied ? 'Copied' : tI18nComplete.raw('textdbf362d4f210'), side: "bottom", children: _jsx(Button, { variant: "ghost", size: "icon", "aria-label": tI18nComplete.raw('textdbf362d4f210'), disabled: !url, onClick: () => void copy(), className: "size-8 active:scale-[0.96]", children: copied ? (_jsx(Check, { className: "text-kortix-green size-4" })) : (_jsx(Link2, { className: "size-4" })) }) }), _jsxs(Button, { variant: "ghost", size: "sm", onClick: onRevoke, disabled: isRevoking, children: [isRevoking ? _jsx(Loading, { className: "size-4 shrink-0" }) : null, tI18nComplete.raw('text87e6d00bbf53')] })] }))] }));
 }
 export function SessionSharesModal({ projectId, sessionId, open, onOpenChange, }) {
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');

package/dist/internal/stores/kortix-computer-store.js

@@ -173,6 +173,20 @@ export const useKortixComputerStore = create()(devtools((set, get) => ({
             get().setIsActionPanelOpen(true);
     },
     setActiveSession: (sessionId, continuity) => {
+        const nextProjectSessionId = continuity?.projectSessionId ?? null;
+        const nextIsTransient = continuity?.transient ?? false;
+        // The boot shell of the session whose real chat already owns the right
+        // side. The two layers mount in either order, and the chat holds the
+        // panel's content: a shell that took over kept the right side after it
+        // faded out, so ⌘I reopened the cards instead of the detail it had
+        // just hidden (KRTX-2944). Not a session change, so nothing moves.
+        if (nextIsTransient &&
+            nextProjectSessionId !== null &&
+            get()._activeSessionId !== null &&
+            !get()._activeIsTransient &&
+            get()._activeProjectSessionId === nextProjectSessionId) {
+            return;
+        }
         // A quick-view is an intent about the session it was made in — it must
         // not replay when some other session mounts later. Cleared even on the
         // no-op re-activation path below, or a request planted for another
@@ -182,8 +196,6 @@ export const useKortixComputerStore = create()(devtools((set, get) => ({
             set({ pendingQuickView: null });
         }
         const prev = get()._activeSessionId;
-        const nextProjectSessionId = continuity?.projectSessionId ?? null;
-        const nextIsTransient = continuity?.transient ?? false;
         if (prev === sessionId) {
             // Same layout re-activating (e.g. the shell flipping transient→ready
             // state, or a tab refocus): keep the continuity bookkeeping fresh so

package/dist/internal/stores/session-hover-store.d.ts

@@ -59,6 +59,38 @@ interface SessionHoverState {
     closeSession: (sessionId: string) => void;
     /** Immediate, for a click that opens something else and for unmount. */
     dismiss: () => void;
+    /**
+     * The row whose session a click just opened. Its card would only describe
+     * the page on screen, so it stays shut until the pointer leaves the row.
+     * Unselected, like `warm`.
+     */
+    suppressedSessionId: string | null;
+    suppress: (sessionId: string) => void;
+    release: (sessionId: string) => void;
 }
 export declare const useSessionHoverStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SessionHoverState>>;
+type RowTarget = {
+    matches?: (selector: string) => boolean;
+};
+/**
+ * A session row's hover wiring (KRTX-2847). The press focuses the row and the
+ * pointer rests on it, so without the click handler every switch showed the
+ * card of the session just opened, 200 ms later, until the page took focus.
+ * Focus leaving the row releases it only when the pointer is elsewhere: the
+ * new page takes focus while the pointer still rests on the row.
+ */
+export declare function sessionRowHoverHandlers(id: string): {
+    onPointerEnter: (event: {
+        pointerType: string;
+        currentTarget: RowTarget;
+    }) => void;
+    onPointerLeave: () => void;
+    onFocus: (event: {
+        currentTarget: RowTarget;
+    }) => void;
+    onBlur: (event: {
+        currentTarget: RowTarget;
+    }) => void;
+    onClick: () => void;
+};
 export {};

package/dist/internal/stores/session-hover-store.js

@@ -65,8 +65,11 @@ export const useSessionHoverStore = create((set, get) => ({
     via: 'pointer',
     slot: null,
     warm: false,
+    suppressedSessionId: null,
     setSlot: (slot) => set({ slot }),
     openSession: (sessionId, anchor, via = 'pointer') => {
+        if (get().suppressedSessionId === sessionId)
+            return;
         closeTimer = cancel(closeTimer);
         warmTimer = cancel(warmTimer);
         // A pending open belongs to whichever row the pointer has just left.
@@ -106,4 +109,39 @@ export const useSessionHoverStore = create((set, get) => ({
         warmTimer = cancel(warmTimer);
         set({ activeSessionId: null, warm: false });
     },
+    suppress: (sessionId) => {
+        set({ suppressedSessionId: sessionId });
+        get().dismiss();
+    },
+    release: (sessionId) => {
+        if (get().suppressedSessionId === sessionId)
+            set({ suppressedSessionId: null });
+    },
 }));
+/**
+ * A session row's hover wiring (KRTX-2847). The press focuses the row and the
+ * pointer rests on it, so without the click handler every switch showed the
+ * card of the session just opened, 200 ms later, until the page took focus.
+ * Focus leaving the row releases it only when the pointer is elsewhere: the
+ * new page takes focus while the pointer still rests on the row.
+ */
+export function sessionRowHoverHandlers(id) {
+    const store = () => useSessionHoverStore.getState();
+    return {
+        onPointerEnter: (event) => {
+            if (event.pointerType !== 'touch')
+                store().openSession(id, event.currentTarget, 'pointer');
+        },
+        onPointerLeave: () => {
+            store().release(id);
+            store().closeSession(id);
+        },
+        onFocus: (event) => store().openSession(id, event.currentTarget, 'focus'),
+        onBlur: (event) => {
+            if (!event.currentTarget.matches?.(':hover'))
+                store().release(id);
+            store().closeSession(id);
+        },
+        onClick: () => store().suppress(id),
+    };
+}

package/dist/internal/stores/sidebar-nav-store.d.ts

@@ -8,7 +8,7 @@
  * (`customize-sidebar-modal.tsx` syncs it). A row a project does not offer (a flag is off, a permission is denied)
  * keeps its place here and simply does not render.
  */
-export declare const SIDEBAR_NAV_ITEM_IDS: readonly ["customize", "apps", "files", "rooms"];
+export declare const SIDEBAR_NAV_ITEM_IDS: readonly ["customize", "apps", "files", "rooms", "goals"];
 export type SidebarNavItemId = (typeof SIDEBAR_NAV_ITEM_IDS)[number];
 /**
  * `never` moves the row into the More menu (`project-nav-items.tsx`), so its

package/dist/internal/stores/sidebar-nav-store.js

@@ -13,7 +13,7 @@ import { registerPersistedStore, resetPersistedStore } from './persisted-store-r
  */
 // Review (2026-10-17) and Reminders (2026-10-19) left the sidebar for Customize
 // tabs. A saved layout that still names one drops the id in `normalizeSidebarNav`.
-export const SIDEBAR_NAV_ITEM_IDS = ['customize', 'apps', 'files', 'rooms'];
+export const SIDEBAR_NAV_ITEM_IDS = ['customize', 'apps', 'files', 'rooms', 'goals'];
 /** The layout before anyone customizes it. */
 export const SIDEBAR_NAV_DEFAULTS = [
     { id: 'customize', visibility: 'always' },
@@ -22,6 +22,8 @@ export const SIDEBAR_NAV_DEFAULTS = [
     // Rooms (2026-10-19, flag `agent_rooms`): chat rooms for sessions and people.
     // In the More menu until the person pins it (2026-10-20).
     { id: 'rooms', visibility: 'never' },
+    // Goals (2026-10-21, flag `goals`): objectives agents own until verified done.
+    { id: 'goals', visibility: 'always' },
 ];
 function isItemId(value) {
     return SIDEBAR_NAV_ITEM_IDS.includes(value);

package/dist/lib/routes.d.ts

@@ -22,6 +22,8 @@ export interface UiRoutes {
     apps: (projectId: string) => string | null;
     /** The project's chat rooms (flag `agent_rooms`). */
     rooms: (projectId: string) => string | null;
+    /** The project's goals (flag `goals`); a goal is `<goals>/<scope>/<slug>`. */
+    goals: (projectId: string) => string | null;
     members: (projectId: string) => string | null;
     /** The project settings page, on its sandbox section. */
     sandboxSettings: (projectId: string) => string | null;

package/dist/lib/routes.js

@@ -6,6 +6,7 @@ const DEFAULT_ROUTES = {
     drive: (p) => `/projects/${p}/drive`,
     apps: (p) => `/projects/${p}/apps`,
     rooms: (p) => `/projects/${p}/rooms`,
+    goals: (p) => `/projects/${p}/goals`,
     members: (p) => `/projects/${p}/members`,
     sandboxSettings: (p) => `/projects/${p}/config?section=sandbox`,
     customize: (p, path) => `/projects/${p}/customize${path ? `/${path}` : ''}`,

package/dist/markdown/genui/components/inline.d.ts

@@ -12,6 +12,6 @@ export declare const genuiBadgeClass: (tone: BadgeTone) => string;
 export declare function GenuiBadge({ props }: GenuiComponentProps): import("react").JSX.Element;
 export declare function GenuiCallout({ props }: GenuiComponentProps): import("react").JSX.Element;
 /** Set inside an image gallery (layout.tsx): the tile sizes the image, which covers it. A `tile` shows its caption on hover. */
-export declare const GenuiImageGridContext: import("react").Context<false | "lead" | "tile">;
+export declare const GenuiImageGridContext: import("react").Context<false | "tile" | "lead">;
 export declare function GenuiImage({ props }: GenuiComponentProps): import("react").JSX.Element;
 export declare function GenuiLink({ props }: GenuiComponentProps): import("react").JSX.Element;

package/dist/markdown/setup-links/app-credentials-form.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The form behind an own-app connect link (`/connect/app/[token]`): the app's
+ * client credentials and the store, for a Composio toolkit that runs on the
+ * customer's own app. Shopify is the one such app today.
+ *
+ * The page opens in the connect popup. The window that opened it polls the
+ * connection, so after a success this window only confirms and closes itself
+ * (or follows the native app's return link).
+ */
+export declare function AppCredentialsForm({ token }: {
+    token: string;
+}): import("react").JSX.Element;