@kortix/ui 0.14.8 → 0.14.10

package/dist/workspace/layout/use-project-home-send.js

@@ -1,8 +1,10 @@
 'use client';
-import { startSessionWithPrompt, writeStartStash } from '@kortix/sdk/react';
+import { qk, removeCachedProjectSession, startSessionWithPrompt, upsertCachedProjectSession, writeStartStash, } from '@kortix/sdk/react';
+import { useQueryClient } from '@tanstack/react-query';
 import { useCallback, useState } from 'react';
 import { useTranslations } from '../../i18n/index.js';
 import { useNewProjectSession } from '../../internal/hooks/projects/use-new-project-session.js';
+import { useUiViewer } from '../../providers/ui-provider.js';
 import { errorToast } from '../../primitives/toast.js';
 import { postWhenUploaded, sentFailureMessage, } from '../../session/composer/attachment-submission.js';
 import { useFirstPromptPreviewStore } from '../../session/composer/stores/session-composer-handoff-store.js';
@@ -14,10 +16,12 @@ import { buildNewSessionCreateInput } from './new-session-create.js';
  * message on its first frame. `ProjectHome` uses it when the host passes no
  * `onSend`.
  */
-export function useProjectHomeSend(projectId, { beforeSend } = {}) {
+export function useProjectHomeSend(projectId, { beforeSend, space } = {}) {
     const tI18nComplete = useTranslations('hardcodedUi.i18nComplete');
     const tComposerAttachments = useTranslations('hardcodedUi.composerAttachments');
     const newSession = useNewProjectSession(projectId);
+    const queryClient = useQueryClient();
+    const viewer = useUiViewer();
     // Composer sending state: spans Enter → create confirmed → navigation. Reset
     // only on create failure (success navigates this page away).
     const [sending, setSending] = useState(false);
@@ -77,10 +81,28 @@ export function useProjectHomeSend(projectId, { beforeSend } = {}) {
         // creates it with these same options. By then the Promise below has
         // rejected, so nothing after the `await` runs.
         let refused = false;
+        let optimisticId = null;
         const sessionId = await new Promise((resolve, reject) => {
             newSession({
+                // A space draws the new thread the instant Enter is pressed; the
+                // create's server row replaces it in place (same id).
+                onCreating: space
+                    ? (id) => {
+                        optimisticId = id;
+                        seedOptimisticThread(queryClient, {
+                            projectId,
+                            spaceId: space.spaceId,
+                            sessionId: id,
+                            text,
+                            agent: options?.agent ?? null,
+                            viewer,
+                            sentAtMs,
+                        });
+                    }
+                    : undefined,
                 create: {
                     ...buildNewSessionCreateInput(options),
+                    ...(space ? { space_id: space.spaceId } : {}),
                     ...(heldAttachments
                         ? {}
                         : {
@@ -100,6 +122,8 @@ export function useProjectHomeSend(projectId, { beforeSend } = {}) {
                 // composer restores its submitted draft and keeps every handle.
                 onError: () => {
                     refused = true;
+                    if (optimisticId)
+                        removeCachedProjectSession(queryClient, projectId, optimisticId);
                     setSending(false);
                     reject(new Error('Session creation failed'));
                 },
@@ -122,15 +146,70 @@ export function useProjectHomeSend(projectId, { beforeSend } = {}) {
                         heldAttachments.resubmit();
                         startHeldPost(heldAttachments, sessionId);
                     }
+                    // A space opens the thread beside its timeline (a gate Retry too).
+                    space?.onOpen(sessionId);
                     resolve(sessionId);
                 },
             });
         });
+        // A space composer stays on screen: it is ready for the next message.
+        if (space)
+            setSending(false);
         if (!heldAttachments) {
             attachments?.release();
             return;
         }
         startHeldPost(heldAttachments, sessionId);
-    }, [beforeSend, newSession, projectId, tI18nComplete, tComposerAttachments]);
+    }, [beforeSend, space, newSession, projectId, tI18nComplete, tComposerAttachments, queryClient, viewer]);
     return { send, sending };
 }
+/**
+ * The new thread's row in its space's cached list, before the create POST: the
+ * viewer as its author (avatar and name, never only an email), the prompt as
+ * its message, and `provisioning`, so the "is working" line shows at once. An
+ * in-flight read of that list is cancelled first: it was sent before this row
+ * existed and would drop it when it lands.
+ */
+function seedOptimisticThread(queryClient, { projectId, spaceId, sessionId, text, agent, viewer, sentAtMs, }) {
+    const prefix = qk.project.sessionsScope(projectId);
+    void queryClient.cancelQueries({
+        queryKey: prefix,
+        predicate: (query) => query.queryKey[prefix.length] === 'list-paged' &&
+            query.queryKey[prefix.length + 2]?.spaceId === spaceId,
+    });
+    const name = viewer?.metadata?.full_name ?? viewer?.metadata?.name;
+    const avatar = viewer?.metadata?.avatar_url;
+    const at = new Date(sentAtMs).toISOString();
+    const row = {
+        session_id: sessionId,
+        account_id: '',
+        project_id: projectId,
+        space_id: spaceId,
+        branch_name: '',
+        base_ref: '',
+        sandbox_provider: null,
+        sandbox_id: null,
+        sandbox_url: null,
+        opencode_session_id: null,
+        opencode_sessions: [],
+        name: null,
+        custom_name: null,
+        agent_name: agent,
+        status: 'provisioning',
+        error: null,
+        metadata: {},
+        first_prompt: text,
+        reply_count: 0,
+        parent_session_id: null,
+        created_by: viewer?.id ?? null,
+        owner_email: viewer?.email ?? null,
+        owner_name: typeof name === 'string' ? name : null,
+        owner_avatar_url: typeof avatar === 'string' ? avatar : null,
+        owner_type: 'user',
+        initiator: { type: 'member', id: viewer?.id ?? null, label: null },
+        is_owner: true,
+        created_at: at,
+        updated_at: at,
+    };
+    upsertCachedProjectSession(queryClient, projectId, row);
+}

package/dist/workspace/memory/body-doc.d.ts

@@ -0,0 +1,17 @@
+import type { JSONContent } from '@tiptap/core';
+export declare function markdownToDoc(markdown: string): JSONContent;
+/** The document as canonical Markdown; empty paragraphs drop out. */
+export declare function docToMarkdown(doc: JSONContent): string;
+/** 12 → "¹²": the font's own superscript figures, sized and set by the font. */
+export declare function superscript(n: number): string;
+/**
+ * A link in a memory file, as the reader opens it: an http(s) URL in a new
+ * tab, a relative path (`profile.md`, `people/priya.md`, `../Notes.md`) as the
+ * memory file it names, resolved against the open file's Drive path. Null
+ * for anything else (an anchor, `mailto:`): the browser handles it.
+ */
+export declare function memoryLinkTarget(href: string, fromPath: string): {
+    url: string;
+} | {
+    path: string;
+} | null;

package/dist/workspace/memory/body-doc.js

@@ -0,0 +1,208 @@
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+const TOKEN = /⟦(\d+)⟧/g;
+/** A text run: ⟦n⟧ becomes a source node, a newline a soft break. */
+function textNodes(value, marks) {
+    const out = [];
+    const push = (text) => {
+        text.split('\n').forEach((line, i) => {
+            if (i > 0)
+                out.push({ type: 'memorySoftBreak' });
+            if (line)
+                out.push(marks.length ? { type: 'text', text: line, marks } : { type: 'text', text: line });
+        });
+    };
+    let at = 0;
+    for (const match of value.matchAll(TOKEN)) {
+        push(value.slice(at, match.index));
+        out.push({ type: 'memorySource', attrs: { number: Number(match[1]) } });
+        at = match.index + match[0].length;
+    }
+    push(value.slice(at));
+    return out;
+}
+function raw(node, source) {
+    const { start, end } = node.position ?? { start: {}, end: {} };
+    return start.offset !== undefined && end.offset !== undefined ? source.slice(start.offset, end.offset) : (node.value ?? '');
+}
+function inlines(nodes, source, marks = []) {
+    return (nodes ?? []).flatMap((node) => {
+        switch (node.type) {
+            case 'text':
+                return textNodes(node.value ?? '', marks);
+            case 'inlineCode':
+                return [{ type: 'text', text: node.value ?? '', marks: [...marks, { type: 'code' }] }];
+            case 'strong':
+                return inlines(node.children, source, [...marks, { type: 'bold' }]);
+            case 'emphasis':
+                return inlines(node.children, source, [...marks, { type: 'italic' }]);
+            case 'delete':
+                return inlines(node.children, source, [...marks, { type: 'strike' }]);
+            case 'link':
+                return inlines(node.children, source, [...marks, { type: 'link', attrs: { href: node.url ?? '' } }]);
+            case 'break':
+                return [{ type: 'hardBreak' }];
+            default:
+                return textNodes(raw(node, source), marks);
+        }
+    });
+}
+const withContent = (node, content) => content.length ? { ...node, content } : node;
+function blocks(nodes, source) {
+    return (nodes ?? []).map((node) => {
+        switch (node.type) {
+            case 'paragraph':
+                return withContent({ type: 'paragraph' }, inlines(node.children, source));
+            case 'heading':
+                return withContent({ type: 'heading', attrs: { level: node.depth ?? 1 } }, inlines(node.children, source));
+            case 'thematicBreak':
+                return { type: 'horizontalRule' };
+            case 'blockquote':
+                return { type: 'blockquote', content: blocks(node.children, source) };
+            case 'code':
+                return withContent({ type: 'codeBlock', attrs: { language: node.lang ?? null } }, node.value ? [{ type: 'text', text: node.value }] : []);
+            case 'list': {
+                const items = node.children ?? [];
+                // A task list is one whose every item has a box; a box in a mixed list stays as its text.
+                const task = items.every((item) => typeof item.checked === 'boolean');
+                const content = items.map((item) => {
+                    const inner = blocks(item.children, source);
+                    const body = inner.length ? inner : [{ type: 'paragraph' }];
+                    if (task)
+                        return { type: 'taskItem', attrs: { checked: !!item.checked }, content: body };
+                    if (typeof item.checked === 'boolean' && body[0]?.type === 'paragraph') {
+                        body[0] = { ...body[0], content: [{ type: 'text', text: item.checked ? '[x] ' : '[ ] ' }, ...(body[0].content ?? [])] };
+                    }
+                    return { type: 'listItem', content: body };
+                });
+                if (task)
+                    return { type: 'taskList', content };
+                return node.ordered
+                    ? { type: 'orderedList', attrs: { start: node.start ?? 1 }, content }
+                    : { type: 'bulletList', content };
+            }
+            case 'table':
+                return {
+                    type: 'table',
+                    content: (node.children ?? []).map((row, r) => ({
+                        type: 'tableRow',
+                        content: (row.children ?? []).map((cell) => ({
+                            type: r === 0 ? 'tableHeader' : 'tableCell',
+                            content: [withContent({ type: 'paragraph' }, inlines(cell.children, source))],
+                        })),
+                    })),
+                };
+            default:
+                return withContent({ type: 'paragraph' }, textNodes(raw(node, source), []));
+        }
+    });
+}
+export function markdownToDoc(markdown) {
+    const source = markdown.replace(/\r\n?/g, '\n');
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(source);
+    const content = blocks(tree.children, source);
+    return { type: 'doc', content: content.length ? content : [{ type: 'paragraph' }] };
+}
+/** Text that would read as Markdown is escaped; `_` only where it could open or close emphasis. */
+function escapeText(text) {
+    return text.replace(/[\\*`[\]]|~~|(?<!\w)_|_(?!\w)/g, (m) => (m === '~~' ? '\\~\\~' : `\\${m}`));
+}
+const isUrl = (href) => /^https?:\/\/\S+$/.test(href);
+function inlineMarkdown(nodes) {
+    return (nodes ?? [])
+        .map((node) => {
+        if (node.type === 'memorySource')
+            return `⟦${node.attrs?.number}⟧`;
+        if (node.type === 'memorySoftBreak')
+            return '\n';
+        if (node.type === 'hardBreak')
+            return '\\\n';
+        const marks = new Map((node.marks ?? []).map((mark) => [mark.type, mark]));
+        const plain = node.text ?? '';
+        let text = marks.has('code') ? `\`${plain}\`` : escapeText(plain);
+        const href = marks.get('link')?.attrs?.href;
+        if (href !== undefined)
+            text = href === plain && isUrl(href) && !marks.has('code') ? plain : `[${text}](${href})`;
+        if (marks.has('italic'))
+            text = `*${text}*`;
+        if (marks.has('strike'))
+            text = `~~${text}~~`;
+        if (marks.has('bold'))
+            text = `**${text}**`;
+        return text;
+    })
+        .join('');
+}
+const indent = (text, by) => text.replace(/\n(?=.)/g, `\n${by}`);
+function listMarkdown(node) {
+    return (node.content ?? [])
+        .map((item, i) => {
+        const marker = node.type === 'orderedList'
+            ? `${Number(node.attrs?.start ?? 1) + i}. `
+            : node.type === 'taskList'
+                ? `- [${item.attrs?.checked ? 'x' : ' '}] `
+                : '- ';
+        // A nested list sits right under its item; other blocks a blank line apart.
+        const parts = (item.content ?? []).map((child) => ({ list: /List$/.test(child.type ?? ''), text: blockMarkdown(child) }));
+        const body = parts.reduce((acc, part, j) => (j === 0 ? part.text : `${acc}${part.list ? '\n' : '\n\n'}${part.text}`), '');
+        return marker + indent(body, ' '.repeat(node.type === 'taskList' ? 2 : marker.length));
+    })
+        .join('\n');
+}
+function tableMarkdown(node) {
+    const rows = (node.content ?? []).map((row) => (row.content ?? []).map((cell) => (cell.content ?? []).map((p) => inlineMarkdown(p.content)).join(' ').replace(/\n/g, ' ').replace(/\|/g, '\\|')));
+    const line = (cells) => `| ${cells.join(' | ')} |`;
+    const [head = [], ...body] = rows;
+    return [line(head), line(head.map(() => '---')), ...body.map(line)].join('\n');
+}
+function blockMarkdown(node) {
+    switch (node.type) {
+        case 'heading':
+            return `${'#'.repeat(Number(node.attrs?.level ?? 1))} ${inlineMarkdown(node.content)}`;
+        case 'bulletList':
+        case 'orderedList':
+        case 'taskList':
+            return listMarkdown(node);
+        case 'blockquote':
+            return docToMarkdown(node)
+                .split('\n')
+                .map((line) => (line ? `> ${line}` : '>'))
+                .join('\n');
+        case 'codeBlock':
+            return `\`\`\`${node.attrs?.language ?? ''}\n${(node.content ?? []).map((c) => c.text ?? '').join('')}\n\`\`\``;
+        case 'horizontalRule':
+            return '---';
+        case 'table':
+            return tableMarkdown(node);
+        default:
+            return inlineMarkdown(node.content);
+    }
+}
+/** The document as canonical Markdown; empty paragraphs drop out. */
+export function docToMarkdown(doc) {
+    return (doc.content ?? [])
+        .map(blockMarkdown)
+        .filter((text) => text.trim())
+        .join('\n\n');
+}
+const SUPERSCRIPT = '⁰¹²³⁴⁵⁶⁷⁸⁹';
+/** 12 → "¹²": the font's own superscript figures, sized and set by the font. */
+export function superscript(n) {
+    return String(n).replace(/\d/g, (digit) => SUPERSCRIPT[Number(digit)]);
+}
+/**
+ * A link in a memory file, as the reader opens it: an http(s) URL in a new
+ * tab, a relative path (`profile.md`, `people/priya.md`, `../Notes.md`) as the
+ * memory file it names, resolved against the open file's Drive path. Null
+ * for anything else (an anchor, `mailto:`): the browser handles it.
+ */
+export function memoryLinkTarget(href, fromPath) {
+    if (isUrl(href))
+        return { url: href };
+    if (!href || /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith('#'))
+        return null;
+    const dir = fromPath.slice(0, fromPath.lastIndexOf('/') + 1) || '/';
+    const resolved = new URL(href.split('#')[0], `file://${dir}`).pathname;
+    return { path: decodeURIComponent(resolved) };
+}

package/dist/workspace/memory/body-extensions.d.ts

@@ -0,0 +1,38 @@
+import { type Extensions, type NodeViewRenderer } from '@tiptap/core';
+/** The body's type, on the V1 scale: one set of classes draws the page and edits it. */
+export declare const BODY_CLASS: {
+    readonly root: "flex flex-col gap-4 outline-none";
+    readonly paragraph: "text-base leading-relaxed text-pretty";
+    readonly heading: "text-base font-semibold";
+    readonly bulletList: "marker:text-muted-foreground flex list-disc flex-col gap-2 pl-5";
+    readonly orderedList: "marker:text-muted-foreground flex list-decimal flex-col gap-2 pl-5";
+    readonly listItem: "text-base leading-relaxed [&>ol]:mt-2 [&>ul]:mt-2";
+    readonly taskList: "flex flex-col gap-2";
+    readonly taskItem: "flex items-start gap-2 text-base leading-relaxed [&_input]:accent-foreground [&>label]:mt-1.5 [&>label]:flex [&>label]:shrink-0 [&>div]:min-w-0 [&>div]:flex-1";
+    readonly blockquote: "text-muted-foreground flex flex-col gap-4 border-l-2 pl-4";
+    readonly codeBlock: "bg-muted overflow-x-auto rounded-md p-3 font-mono text-xs";
+    readonly horizontalRule: "border-border my-2";
+    readonly table: "w-full border-collapse text-sm";
+    readonly tableCell: "border-border border px-3 py-1.5 text-left align-top";
+    readonly tableHeader: "border-border border px-3 py-1.5 text-left align-top font-semibold";
+    readonly code: "bg-muted rounded-sm px-1 font-mono";
+    readonly bold: "font-semibold";
+    readonly italic: "italic";
+    readonly strike: "line-through";
+    readonly link: "underline underline-offset-2 cursor-pointer";
+    /** `SourceMark`'s classes, without its hover. */
+    readonly source: "text-foreground -mx-0.5 -my-1 rounded-sm px-0.5 py-1";
+};
+interface MemorySourceOptions {
+    /** The page's source numbers; a number outside it draws nothing and is kept. Null draws every number. */
+    known: ReadonlySet<number> | null;
+    /** The host's view of a number (the reader's `SourceMark`); absent, a plain superscript. */
+    view: NodeViewRenderer | null;
+}
+/**
+ * The memory body's schema: the GFM subset `body-doc.ts` reads and writes,
+ * with its Markdown shortcuts (`## `, `- `, `1. `, `[ ] `, `> `, `**bold**`,
+ * `*italic*`, `` `code` ``, ``` fences, `---`). No toolbar.
+ */
+export declare function memoryBodyExtensions(options?: Partial<MemorySourceOptions>): Extensions;
+export {};

package/dist/workspace/memory/body-extensions.js

@@ -0,0 +1,103 @@
+import { Node } from '@tiptap/core';
+import { TaskItem, TaskList } from '@tiptap/extension-list';
+import { TableKit } from '@tiptap/extension-table';
+import StarterKit from '@tiptap/starter-kit';
+import { superscript } from './body-doc.js';
+/** The body's type, on the V1 scale: one set of classes draws the page and edits it. */
+export const BODY_CLASS = {
+    root: 'flex flex-col gap-4 outline-none',
+    paragraph: 'text-base leading-relaxed text-pretty',
+    heading: 'text-base font-semibold',
+    bulletList: 'marker:text-muted-foreground flex list-disc flex-col gap-2 pl-5',
+    orderedList: 'marker:text-muted-foreground flex list-decimal flex-col gap-2 pl-5',
+    listItem: 'text-base leading-relaxed [&>ol]:mt-2 [&>ul]:mt-2',
+    taskList: 'flex flex-col gap-2',
+    taskItem: 'flex items-start gap-2 text-base leading-relaxed [&_input]:accent-foreground [&>label]:mt-1.5 [&>label]:flex [&>label]:shrink-0 [&>div]:min-w-0 [&>div]:flex-1',
+    blockquote: 'text-muted-foreground flex flex-col gap-4 border-l-2 pl-4',
+    codeBlock: 'bg-muted overflow-x-auto rounded-md p-3 font-mono text-xs',
+    horizontalRule: 'border-border my-2',
+    table: 'w-full border-collapse text-sm',
+    tableCell: 'border-border border px-3 py-1.5 text-left align-top',
+    tableHeader: 'border-border border px-3 py-1.5 text-left align-top font-semibold',
+    code: 'bg-muted rounded-sm px-1 font-mono',
+    bold: 'font-semibold',
+    italic: 'italic',
+    strike: 'line-through',
+    link: 'underline underline-offset-2 cursor-pointer',
+    /** `SourceMark`'s classes, without its hover. */
+    source: 'text-foreground -mx-0.5 -my-1 rounded-sm px-0.5 py-1',
+};
+/**
+ * ⟦n⟧: the source number, a superscript that the caret steps over and
+ * Backspace deletes whole.
+ */
+const MemorySource = Node.create({
+    name: 'memorySource',
+    addOptions: () => ({ known: null, view: null }),
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: false,
+    addAttributes: () => ({ number: { default: 1 } }),
+    parseHTML: () => [{ tag: 'span[data-memory-source]' }],
+    renderHTML({ node }) {
+        const number = Number(node.attrs.number);
+        const shown = !this.options.known || this.options.known.has(number);
+        return [
+            'span',
+            { 'data-memory-source': number, contenteditable: 'false', class: shown ? BODY_CLASS.source : 'hidden' },
+            shown ? superscript(number) : '',
+        ];
+    },
+    addNodeView() {
+        return this.options.view;
+    },
+    renderText: ({ node }) => `⟦${node.attrs.number}⟧`,
+});
+/** A line break inside a paragraph's Markdown: drawn as the space Markdown makes of it. */
+const MemorySoftBreak = Node.create({
+    name: 'memorySoftBreak',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: false,
+    parseHTML: () => [{ tag: 'span[data-memory-soft-break]' }],
+    renderHTML: () => ['span', { 'data-memory-soft-break': '' }, ' '],
+    renderText: () => ' ',
+});
+/**
+ * The memory body's schema: the GFM subset `body-doc.ts` reads and writes,
+ * with its Markdown shortcuts (`## `, `- `, `1. `, `[ ] `, `> `, `**bold**`,
+ * `*italic*`, `` `code` ``, ``` fences, `---`). No toolbar.
+ */
+export function memoryBodyExtensions(options = {}) {
+    const attrs = (name) => ({ HTMLAttributes: { class: BODY_CLASS[name] } });
+    return [
+        StarterKit.configure({
+            underline: false,
+            trailingNode: false,
+            paragraph: attrs('paragraph'),
+            heading: attrs('heading'),
+            bulletList: attrs('bulletList'),
+            orderedList: attrs('orderedList'),
+            listItem: attrs('listItem'),
+            blockquote: attrs('blockquote'),
+            codeBlock: attrs('codeBlock'),
+            horizontalRule: attrs('horizontalRule'),
+            code: attrs('code'),
+            bold: attrs('bold'),
+            italic: attrs('italic'),
+            strike: attrs('strike'),
+            link: { openOnClick: false, autolink: false, HTMLAttributes: { class: BODY_CLASS.link, rel: null, target: null } },
+        }),
+        TaskList.configure(attrs('taskList')),
+        TaskItem.configure({ nested: true, ...attrs('taskItem') }),
+        TableKit.configure({
+            table: { resizable: false, HTMLAttributes: { class: BODY_CLASS.table } },
+            tableCell: attrs('tableCell'),
+            tableHeader: attrs('tableHeader'),
+        }),
+        MemorySource.configure({ known: options.known ?? null, view: options.view ?? null }),
+        MemorySoftBreak,
+    ];
+}

package/dist/workspace/memory/company-memory-page.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The project's Memory page: the Company layer, what every agent in the
+ * project knows. The titlebar row of a channel, then the same `MemoryView` a
+ * channel's Memory tab draws. The host gates it on `project_channels`.
+ */
+export declare function CompanyMemoryPage({ projectId }: {
+    projectId: string;
+}): import("react").JSX.Element;

package/dist/workspace/memory/company-memory-page.js

@@ -0,0 +1,16 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslations } from '../../i18n/index.js';
+import { SidebarToggle } from '../../internal/layout/sidebar-toggle.js';
+import { useOptionalSidebar } from '../../primitives/sidebar.js';
+import { MemoryView } from './memory-view.js';
+/**
+ * The project's Memory page: the Company layer, what every agent in the
+ * project knows. The titlebar row of a channel, then the same `MemoryView` a
+ * channel's Memory tab draws. The host gates it on `project_channels`.
+ */
+export function CompanyMemoryPage({ projectId }) {
+    const t = useTranslations('spaces.memory.company');
+    const sidebar = useOptionalSidebar();
+    return (_jsxs("div", { className: "bg-background flex min-h-0 flex-1 flex-col overflow-hidden", children: [_jsxs("div", { className: "kx-titlebar-row kx-capability-titlebar relative flex shrink-0 items-center gap-2 border-b px-2", "data-sidebar-collapsed": sidebar?.state === 'collapsed' || undefined, children: [_jsx(SidebarToggle, {}), _jsxs("div", { className: "kx-titlebar-tabs flex h-12 min-w-0 flex-1 items-baseline gap-2 px-2", children: [_jsx("h1", { className: "shrink-0 self-center text-lg font-semibold", children: t('title') }), _jsx("p", { className: "text-muted-foreground min-w-0 truncate self-center text-xs", children: t('subtitle') })] })] }), _jsx("div", { className: "relative min-h-0 flex-1 overflow-hidden", children: _jsx("div", { className: "absolute inset-0 flex flex-col", children: _jsx(MemoryView, { projectId: projectId, layerKey: "company", place: t('place') }) }) })] }));
+}

package/dist/workspace/memory/memory-all.d.ts

@@ -0,0 +1,20 @@
+import type { ProjectMemoryPageSummary } from '@kortix/sdk';
+/**
+ * The layer at a glance, the landing view of a channel's, a DM's and the
+ * Company memory: "All" and "16 pages", one line on what memory is, then a
+ * card per page in the list's groups (About first). A card shows the title,
+ * "Updated 2h ago" and the page's opening, fading out; it opens the page.
+ */
+export declare function MemoryAll({ kind, place, pages, onSelect, className, }: {
+    kind: 'company' | 'channel' | 'dm';
+    /** "#marketing" or the DM's agent. */
+    place: string;
+    /** Sorted by `sortMemoryPages`. */
+    pages: readonly ProjectMemoryPageSummary[];
+    onSelect: (pageId: string) => void;
+    className?: string;
+}): import("react").JSX.Element;
+/** The All view's line boxes while the layer loads. */
+export declare function MemoryAllSkeleton({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/dist/workspace/memory/memory-all.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { SunDimIcon } from '@phosphor-icons/react';
+import { useLocale, useTranslations } from '../../i18n/index.js';
+import { relativeTime } from '../../internal/lib/relative-time.js';
+import { cn } from '../../lib/utils.js';
+import { Skeleton } from '../../primitives/skeleton.js';
+import { groupMemoryPages } from './memory-page-list.js';
+import { Line } from './memory-reader.js';
+/** The reader's frame: the All view and its skeleton sit where a page's title does. */
+const FRAME = 'flex flex-col px-6 py-8 @2xl/reader:px-16 @2xl/reader:py-10';
+const GRID = 'grid grid-cols-[repeat(auto-fill,minmax(12.5rem,1fr))] gap-3';
+/**
+ * The layer at a glance, the landing view of a channel's, a DM's and the
+ * Company memory: "All" and "16 pages", one line on what memory is, then a
+ * card per page in the list's groups (About first). A card shows the title,
+ * "Updated 2h ago" and the page's opening, fading out; it opens the page.
+ */
+export function MemoryAll({ kind, place, pages, onSelect, className, }) {
+    const t = useTranslations('spaces.memory');
+    const locale = useLocale();
+    return (_jsx("div", { className: cn('@container/reader min-h-0 flex-1 overflow-y-auto', className), children: _jsxs("div", { className: FRAME, children: [_jsxs("header", { className: "flex flex-col gap-1.5", children: [_jsx("h2", { className: "text-2xl leading-tight font-semibold tracking-tight", children: t('all.title') }), _jsx("p", { className: "text-muted-foreground text-xs leading-snug tabular-nums", children: t('pageCount', { count: pages.length }) })] }), _jsxs("p", { className: "text-muted-foreground mt-6 flex items-center gap-2.5 rounded-md border px-3 py-2 text-xs", children: [_jsx("span", { className: "bg-muted text-foreground flex size-6 shrink-0 items-center justify-center rounded-sm", children: _jsx(SunDimIcon, { "aria-hidden": true, className: "size-3.5" }) }), _jsx("span", { className: "min-w-0 text-pretty", children: t(kind === 'company' ? 'all.explainCompany' : kind === 'dm' ? 'all.explainDm' : 'all.explainChannel', { place }) })] }), groupMemoryPages(pages).map((group) => (_jsxs("section", { "aria-label": t(`group.${group.type}`), className: "mt-8 flex flex-col gap-2", children: [_jsx("h3", { className: "text-muted-foreground text-xs", children: t(`group.${group.type}`) }), _jsx("ul", { className: GRID, children: group.pages.map((page) => (_jsx("li", { className: "flex", children: _jsxs("button", { type: "button", onClick: () => onSelect(page.page_id), className: "hover:bg-secondary focus-visible:ring-ring duration-fast flex w-full flex-col gap-1 rounded-md border px-3 py-2.5 text-left outline-none transition-colors focus-visible:ring-2", children: [_jsx("span", { className: "text-foreground line-clamp-2 text-sm font-medium text-pretty [overflow-wrap:anywhere]", children: page.title }), _jsx("span", { className: "text-muted-foreground text-xs", children: t('updatedAt', { time: relativeTime(page.updated_at, locale) }) }), page.excerpt ? (_jsx("span", { className: "text-muted-foreground mt-1 line-clamp-4 mask-b-from-50% text-xs leading-relaxed [overflow-wrap:anywhere]", children: page.excerpt })) : null] }) }, page.page_id))) })] }, group.type)))] }) }));
+}
+/** The All view's line boxes while the layer loads. */
+export function MemoryAllSkeleton({ className }) {
+    return (_jsx("div", { "aria-hidden": true, className: cn('@container/reader min-h-0 flex-1 overflow-hidden', className), children: _jsxs("div", { className: FRAME, children: [_jsxs("div", { className: "flex flex-col gap-1.5", children: [_jsx(Line, { line: "text-2xl leading-tight", className: "h-5 w-16" }), _jsx(Line, { line: "text-xs leading-snug", className: "h-2.5 w-14" })] }), _jsx(Skeleton, { className: "mt-6 h-11 w-full rounded-md py-0" }), _jsxs("div", { className: "mt-8 flex flex-col gap-2", children: [_jsx(Skeleton, { className: "h-2.5 w-12 rounded-sm py-0" }), _jsx("div", { className: GRID, children: [0, 1, 2].map((index) => (_jsx(Skeleton, { className: "h-32 rounded-md py-0" }, index))) })] })] }) }));
+}

package/dist/workspace/memory/memory-body.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectMemoryPage, type ProjectMemoryPageSummary } from '@kortix/sdk';
+/**
+ * The page's body, read and edited with one renderer: the reader's look is
+ * the editor's, so Edit changes nothing but the caret. While editing: Markdown
+ * shortcuts, no toolbar, Cancel and Save under it; Esc cancels, ⌘Enter saves.
+ * A link opens while reading: a URL in a new tab, a relative path as the
+ * memory page it names. Save sends the version it started from; a page
+ * changed meanwhile answers `version_conflict`, and Reload loads it.
+ */
+export declare function MemoryBody({ projectId, page, pages, editing, onSelectPage, onDone, onReload, }: {
+    projectId: string;
+    page: ProjectMemoryPage;
+    /** The layer's pages: where a relative link goes. */
+    pages: readonly ProjectMemoryPageSummary[];
+    editing: boolean;
+    onSelectPage: (pageId: string) => void;
+    onDone: () => void;
+    onReload: () => void;
+}): import("react").JSX.Element;