@listen1954/board 0.1.0

package/lib/tools.js

@@ -0,0 +1,594 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+const SCOPE = {
+    type: 'string',
+    enum: ['global', 'session'],
+    required: true,
+    description: 'View/mutation target: global shows every normal and session-linked column; session projects only this conversation task column.',
+};
+const REMINDER_VALUE = {
+    oneOf: [
+        { type: 'null' },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                at: { type: 'string', required: true },
+                text: { type: 'string', required: true },
+                status: { type: 'string', required: true, enum: ['scheduled', 'fired', 'cancelled'] },
+                firedAt: { type: 'string' },
+            },
+        },
+    ],
+};
+const CARD_VALUE = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        id: { type: 'string', required: true },
+        columnId: { type: 'string', required: true },
+        title: { type: 'string', required: true },
+        body: { type: 'string', required: true },
+        order: { type: 'integer', required: true },
+        startAt: { required: true, oneOf: [{ type: 'null' }, { type: 'string' }] },
+        endAt: { required: true, oneOf: [{ type: 'null' }, { type: 'string' }] },
+        reminder: { ...REMINDER_VALUE, required: true },
+        timeReminder: {
+            type: 'object',
+            required: true,
+            additionalProperties: false,
+            properties: {
+                enabled: { type: 'boolean', required: true },
+                startFiredAt: { type: 'string' },
+                endFiredAt: { type: 'string' },
+            },
+        },
+        logs: {
+            type: 'array',
+            required: true,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    id: { type: 'string', required: true },
+                    text: { type: 'string', required: true },
+                    createdAt: { type: 'string', required: true },
+                    attachments: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { id: { type: 'string', required: true }, name: { type: 'string', required: true }, type: { type: 'string', required: true }, size: { type: 'integer', required: true } } } },
+                },
+            },
+        },
+        archivedAt: {
+            required: true,
+            oneOf: [{ type: 'null' }, { type: 'string' }],
+        },
+        archivedColumn: {
+            required: true,
+            oneOf: [
+                { type: 'null' },
+                { type: 'object', additionalProperties: false, properties: { id: { type: 'string', required: true }, title: { type: 'string', required: true }, sessionId: { type: 'string' } } },
+            ],
+        },
+        createdAt: { type: 'string', required: true },
+        updatedAt: { type: 'string', required: true },
+    },
+};
+const BOARD_VALUE = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        schemaVersion: { type: 'integer', const: 1, required: true },
+        id: { type: 'string', required: true },
+        scope: { type: 'string', required: true, enum: ['global', 'session'] },
+        sessionId: { type: 'string' },
+        title: { type: 'string', required: true },
+        columns: {
+            type: 'array',
+            required: true,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    id: { type: 'string', required: true },
+                    title: { type: 'string', required: true },
+                    order: { type: 'integer', required: true },
+                    sessionId: { type: 'string', description: 'Present when this is the canonical task column of a conversation.' },
+                },
+            },
+        },
+        cards: {
+            type: 'array',
+            required: true,
+            items: CARD_VALUE,
+        },
+        revision: { type: 'integer', required: true },
+        updatedAt: { type: 'string', required: true },
+    },
+};
+const SUMMARY_VALUE = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        scope: { type: 'string', required: true, enum: ['global', 'session'] },
+        id: { type: 'string', required: true },
+        title: { type: 'string', required: true },
+        revision: { type: 'integer', required: true },
+        updatedAt: { type: 'string', required: true },
+        empty: { type: 'boolean', required: true },
+        reminderFiredCount: { type: 'integer', required: true },
+        archivedCount: { type: 'integer', required: true },
+        columns: {
+            type: 'array',
+            required: true,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    id: { type: 'string', required: true },
+                    title: { type: 'string', required: true },
+                    sessionId: { type: 'string', description: 'Present for a session-linked column.' },
+                    cards: {
+                        type: 'array',
+                        required: true,
+                        items: {
+                            type: 'object',
+                            additionalProperties: false,
+                            properties: {
+                                id: { type: 'string', required: true },
+                                title: { type: 'string', required: true },
+                                reminderStatus: {
+                                    required: true,
+                                    oneOf: [
+                                        { type: 'null' },
+                                        { type: 'string', enum: ['scheduled', 'fired', 'cancelled'] },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const SEARCH_RESULT_VALUE = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        cardId: { type: 'string', required: true },
+        title: { type: 'string', required: true },
+        columnId: { type: 'string', required: true },
+        columnTitle: { type: 'string', required: true },
+        sessionId: { type: 'string' },
+        status: { type: 'string', required: true, enum: ['active', 'archived'] },
+        archivedAt: { required: true, oneOf: [{ type: 'null' }, { type: 'string' }] },
+        matchedIn: { type: 'array', required: true, items: { type: 'string', enum: ['title', 'body', 'log', 'attachment', 'column'] } },
+        preview: { type: 'string', required: true },
+    },
+};
+const MUTATE_OP = {
+    oneOf: [
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'addColumn', required: true, description: 'Create a column. Use its returned id for addCard.' },
+                title: { type: 'string', required: true, description: 'Column title. Columns have no built-in meaning.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'renameColumn', required: true, description: 'Rename an existing column; obtain columnId from board_list.' },
+                columnId: { type: 'string', required: true },
+                title: { type: 'string', required: true },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'reorderColumns', required: true, description: 'Reorder columns using every current column id exactly once.' },
+                columnIds: {
+                    type: 'array',
+                    required: true,
+                    items: { type: 'string' },
+                    description: 'Every column id, left to right.',
+                },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'deleteColumn', required: true, description: 'Permanently delete a column and its active cards. Completed cards and attachments are preserved.' },
+                columnId: { type: 'string', required: true },
+                confirm: { type: 'boolean', const: true, required: true, description: 'Must be true. Deletes the column and active cards.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'addCard', required: true, description: 'Create a task card in an existing column. Include body and task start/end times when known.' },
+                columnId: { type: 'string', required: true },
+                title: { type: 'string', required: true },
+                body: { type: 'string', description: 'Optional notes.' },
+                startAt: { type: 'string', description: 'Optional task start time as ISO-8601. May be used without endAt.' },
+                endAt: { type: 'string', description: 'Optional task end/deadline as ISO-8601. May be used without startAt.' },
+                timeReminder: { type: 'boolean', description: 'Notify at the task start and end times. Requires at least one task time.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'updateCard', required: true, description: 'Edit title, notes, task start/end times, and/or task-time notifications in one operation. startAt/endAt:null clears that field.' },
+                cardId: { type: 'string', required: true },
+                title: { type: 'string' },
+                body: { type: 'string' },
+                startAt: { oneOf: [{ type: 'null' }, { type: 'string' }], description: 'Set or clear task start time.' },
+                endAt: { oneOf: [{ type: 'null' }, { type: 'string' }], description: 'Set or clear task end/deadline.' },
+                timeReminder: { type: 'boolean', description: 'Enable or disable notifications at task start/end.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'moveCard', required: true, description: 'Move or reorder a card. index is zero-based among active destination cards.' },
+                cardId: { type: 'string', required: true },
+                columnId: { type: 'string', required: true, description: 'Destination column.' },
+                index: { type: 'integer', required: true, description: '0-based index in the destination column.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'addLog', required: true, description: 'Append an immutable progress note, blocker, decision, or process memo to a card.' },
+                cardId: { type: 'string', required: true },
+                text: { type: 'string', required: true },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'archiveCard', required: true, description: 'Mark a task complete by archiving it. Do not delete completed work.' },
+                cardId: { type: 'string', required: true },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'restoreCard', required: true, description: 'Restore an archived card into a selected existing column.' },
+                cardId: { type: 'string', required: true },
+                columnId: { type: 'string', required: true, description: 'Column to restore the archived card into.' },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'restoreCards', required: true, description: 'Atomically restore multiple archived cards.' },
+                cards: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: { cardId: { type: 'string', required: true }, columnId: { type: 'string', required: true } } } },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'deleteCard', required: true, description: 'Permanently delete a card. Only use on an explicit user request.' },
+                cardId: { type: 'string', required: true },
+            },
+        },
+        {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'deleteCards', required: true, description: 'Atomically and permanently delete multiple cards. Only use on an explicit user request.' },
+                cardIds: { type: 'array', required: true, items: { type: 'string' } },
+            },
+        },
+    ],
+};
+export function registerBoardTools(ctx) {
+    ctx.tools.register(defineTool({
+        name: 'board_list',
+        description: 'Summarize the global board and this session\'s board: column names, card titles, fired reminder counts. '
+            + 'Use for overview and browsing, not as a prerequisite for every mutation. Does not return notes or archived card details, but reports archivedCount. '
+            + 'The global summary includes session-linked columns; the session summary is only this conversation. Use board_search when the user gives a title, keyword, note, log, attachment, or column to find.',
+        parameters: {},
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    boards: { type: 'array', required: true, items: SUMMARY_VALUE },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderList(value.boards) }],
+        },
+        isConcurrencySafe: () => true,
+        async execute(_args, exec) {
+            const boards = await ctx.board.list(requireCallerSession(exec));
+            return { boards: boards.map(toSummaryValue) };
+        },
+        presentCall: () => ({ card: 'generic', title: 'List boards', kind: 'read' }),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'board_get',
+        description: 'Read the global board or this session\'s board. Pass cardId to get one card including notes. '
+            + 'A full board includes active and archived cards; archived cards have archivedAt set. '
+            + 'Global scope includes every session-linked column; session scope only projects this conversation. If cardId is unknown, use board_search for a described task or board_list only for an overview.',
+        parameters: {
+            scope: SCOPE,
+            cardId: { type: 'string', description: 'If set, return that card (with notes) instead of the whole board.' },
+        },
+        output: {
+            schema: {
+                oneOf: [
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: { board: { ...BOARD_VALUE, required: true } },
+                    },
+                    {
+                        type: 'object',
+                        additionalProperties: false,
+                        properties: { card: { ...CARD_VALUE, required: true } },
+                    },
+                ],
+            },
+            render: (_args, value) => [{ type: 'text', text: renderGet(value) }],
+        },
+        isConcurrencySafe: () => true,
+        async execute(args, exec) {
+            const sessionId = requireCallerSession(exec);
+            const scope = args.scope;
+            if (args.cardId !== undefined && args.cardId.length > 0) {
+                const card = await ctx.board.getCard(sessionId, scope, args.cardId);
+                return { card: toCardValue(card) };
+            }
+            const board = await ctx.board.getBoard(sessionId, scope);
+            return { board: toBoardValue(board) };
+        },
+        presentCall: (args) => ({
+            card: 'generic',
+            title: args.cardId ? 'Get card' : 'Get board',
+            kind: 'read',
+            rawInput: args,
+        }),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'board_search',
+        description: 'Search cards without loading the full board. Matches card titles, notes, process logs, attachment names, and current or archived column names. '
+            + 'Use scope: global from any conversation to search and control the entire board; use session only to restrict results to this conversation. '
+            + 'Results include card IDs for board_get or board_apply.',
+        parameters: {
+            scope: SCOPE,
+            query: { type: 'string', required: true, description: 'Non-empty case-insensitive text to find.' },
+            status: { type: 'string', enum: ['all', 'active', 'archived'], description: 'Optional card state filter. Defaults to all.' },
+            limit: { type: 'integer', description: 'Maximum returned matches, clamped to 1-100. Defaults to 20.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    query: { type: 'string', required: true },
+                    total: { type: 'integer', required: true },
+                    results: { type: 'array', required: true, items: SEARCH_RESULT_VALUE },
+                },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderSearch(value) }],
+        },
+        isConcurrencySafe: () => true,
+        async execute(args, exec) {
+            const board = await ctx.board.getBoard(requireCallerSession(exec), args.scope);
+            return searchBoard(board, args.query, args.status ?? 'all', args.limit ?? 20);
+        },
+        presentCall: (args) => ({ card: 'generic', title: 'Search board', kind: 'read', rawInput: args }),
+    }));
+    ctx.tools.register(defineTool({
+        name: 'board_apply',
+        description: 'Apply one mutation to the global board or this session\'s board. Same operations the UI uses. '
+            + 'Resolve unknown IDs with board_search when the user describes a target, or board_list when browsing; do not call both without a reason. Reuse each successful response instead of reading again. '
+            + 'If a board has no columns, addColumn once and use its returned id for addCard. Never invent IDs. '
+            + 'If an operation fails, read the error and refresh once; do not repeat the identical failed call. Session scope cannot target other sessions; global scope can modify any visible column. '
+            + 'Use archiveCard for completion and restoreCard to return it to a chosen column. '
+            + 'deleteColumn requires confirm: true, deletes active cards in that column, and preserves completed history.',
+        parameters: {
+            scope: SCOPE,
+            op: { ...MUTATE_OP, required: true, description: 'One mutate operation.' },
+        },
+        output: {
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: { board: { ...BOARD_VALUE, required: true } },
+            },
+            render: (_args, value) => [{ type: 'text', text: renderBoard(value.board) }],
+        },
+        async execute(args, exec) {
+            const board = await ctx.board.model.mutate(requireCallerSession(exec), args.scope, args.op);
+            return { board: toBoardValue(board) };
+        },
+        presentCall: (args) => ({
+            card: 'generic',
+            title: `Board ${args.op.type}`,
+            kind: 'other',
+            rawInput: args,
+        }),
+    }));
+}
+export function searchBoard(board, rawQuery, status = 'all', limit = 20) {
+    const query = rawQuery.trim();
+    if (query.length === 0)
+        throw new Error('board search query must not be empty');
+    const needle = normalizeSearch(query);
+    const matches = board.cards.flatMap((card) => {
+        const cardStatus = card.archivedAt === null ? 'active' : 'archived';
+        if (status !== 'all' && status !== cardStatus)
+            return [];
+        const column = board.columns.find((item) => item.id === card.columnId);
+        const columnTitle = card.archivedColumn?.title ?? column?.title ?? '';
+        const sessionId = card.archivedColumn?.sessionId ?? column?.sessionId;
+        const fields = [
+            ['title', [card.title]],
+            ['body', [card.body]],
+            ['log', card.logs.map((log) => log.text)],
+            ['attachment', card.logs.flatMap((log) => log.attachments.map((attachment) => attachment.name))],
+            ['column', [columnTitle]],
+        ];
+        const matchedIn = fields.flatMap(([field, values]) => values.some((value) => normalizeSearch(value).includes(needle)) ? [field] : []);
+        if (matchedIn.length === 0)
+            return [];
+        const previewSource = fields.find(([field]) => matchedIn.includes(field))?.[1].find((value) => normalizeSearch(value).includes(needle)) ?? card.title;
+        const score = (matchedIn.includes('title') ? 100 : 0) + (matchedIn.includes('body') ? 30 : 0) + (matchedIn.includes('log') ? 20 : 0) + (matchedIn.includes('attachment') ? 10 : 0) + (matchedIn.includes('column') ? 5 : 0);
+        return [{
+                score,
+                cardId: card.id,
+                title: card.title,
+                columnId: card.columnId,
+                columnTitle,
+                ...(sessionId === undefined ? {} : { sessionId }),
+                status: cardStatus,
+                archivedAt: card.archivedAt,
+                matchedIn,
+                preview: searchPreview(previewSource, needle),
+                updatedAt: card.updatedAt,
+            }];
+    }).sort((a, b) => b.score - a.score || Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+    return {
+        query,
+        total: matches.length,
+        results: matches.slice(0, Math.max(1, Math.min(100, limit))).map(({ score: _score, updatedAt: _updatedAt, ...result }) => result),
+    };
+}
+function normalizeSearch(value) {
+    return value.toLocaleLowerCase();
+}
+function searchPreview(value, needle) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    const index = normalizeSearch(compact).indexOf(needle);
+    if (index < 0 || compact.length <= 160)
+        return compact;
+    const start = Math.max(0, index - 60);
+    const end = Math.min(compact.length, start + 160);
+    return `${start > 0 ? '…' : ''}${compact.slice(start, end)}${end < compact.length ? '…' : ''}`;
+}
+export function requireCallerSession(exec) {
+    const agent = exec.agent;
+    if (agent === undefined) {
+        throw new Error('board tools require an owning agent session');
+    }
+    return agent.session.id;
+}
+function toReminderValue(reminder) {
+    if (reminder === null)
+        return null;
+    return {
+        at: reminder.at,
+        text: reminder.text,
+        status: reminder.status,
+        ...(reminder.firedAt === undefined ? {} : { firedAt: reminder.firedAt }),
+    };
+}
+function toCardValue(card) {
+    return {
+        id: card.id,
+        columnId: card.columnId,
+        title: card.title,
+        body: card.body,
+        order: card.order,
+        startAt: card.startAt,
+        endAt: card.endAt,
+        reminder: toReminderValue(card.reminder),
+        timeReminder: card.timeReminder,
+        logs: card.logs.map((log) => ({ ...log, attachments: log.attachments.map((attachment) => ({ id: attachment.id, name: attachment.name, type: attachment.type, size: attachment.size })) })),
+        archivedAt: card.archivedAt,
+        archivedColumn: card.archivedColumn,
+        createdAt: card.createdAt,
+        updatedAt: card.updatedAt,
+    };
+}
+function toBoardValue(board) {
+    return {
+        schemaVersion: 1,
+        id: board.id,
+        scope: board.scope,
+        ...(board.sessionId === undefined ? {} : { sessionId: board.sessionId }),
+        title: board.title,
+        columns: board.columns.map((column) => ({
+            id: column.id,
+            title: column.title,
+            order: column.order,
+            ...(column.sessionId === undefined ? {} : { sessionId: column.sessionId }),
+        })),
+        cards: board.cards.map(toCardValue),
+        revision: board.revision,
+        updatedAt: board.updatedAt,
+    };
+}
+function toSummaryValue(summary) {
+    return {
+        scope: summary.scope,
+        id: summary.id,
+        title: summary.title,
+        revision: summary.revision,
+        updatedAt: summary.updatedAt,
+        empty: summary.empty,
+        reminderFiredCount: summary.reminderFiredCount,
+        archivedCount: summary.archivedCount,
+        columns: summary.columns.map((column) => ({
+            id: column.id,
+            title: column.title,
+            ...(column.sessionId === undefined ? {} : { sessionId: column.sessionId }),
+            cards: column.cards.map((card) => ({
+                id: card.id,
+                title: card.title,
+                reminderStatus: card.reminderStatus,
+            })),
+        })),
+    };
+}
+function renderList(boards) {
+    return boards.map((board) => {
+        const where = board.scope === 'global' ? 'global' : 'this session';
+        if (board.empty)
+            return `${where}: empty (no columns)`;
+        const cols = board.columns.map((column) => {
+            const titles = column.cards.map((card) => card.title).join(', ');
+            return `${column.title}[${titles || 'no cards'}]`;
+        }).join('; ');
+        const due = board.reminderFiredCount > 0 ? `; ${String(board.reminderFiredCount)} fired reminder(s)` : '';
+        const archived = board.archivedCount > 0 ? `; ${String(board.archivedCount)} archived card(s)` : '';
+        return `${where} (rev ${String(board.revision)}): ${cols}${due}${archived}`;
+    }).join('\n');
+}
+function renderSearch(value) {
+    if (value.total === 0)
+        return `No board cards matched "${value.query}".`;
+    const lines = value.results.map((result) => {
+        const where = result.sessionId === undefined ? result.columnTitle : `${result.columnTitle} (session ${result.sessionId})`;
+        const preview = result.preview.length > 0 && result.preview !== result.title ? ` — ${result.preview}` : '';
+        return `- ${result.cardId} [${result.status}] ${result.title} · ${where} · matched ${result.matchedIn.join(', ')}${preview}`;
+    });
+    const suffix = value.total > value.results.length ? `\nShowing ${String(value.results.length)} of ${String(value.total)} matches.` : '';
+    return `Found ${String(value.total)} board card(s) matching "${value.query}":\n${lines.join('\n')}${suffix}`;
+}
+function renderGet(value) {
+    if ('card' in value) {
+        const card = value.card;
+        const note = card.body.length > 0 ? `\nnotes: ${card.body}` : '';
+        const reminder = card.reminder ? `\nreminder: ${card.reminder.status} at ${card.reminder.at}` : '';
+        return `card ${card.id}: ${card.title}${note}${reminder}`;
+    }
+    return renderBoard(value.board);
+}
+function renderBoard(board) {
+    const where = board.scope === 'global' ? 'global' : 'this session';
+    return `Updated ${where} board (revision ${String(board.revision)}): ${String(board.columns.length)} column(s), ${String(board.cards.length)} card(s).`;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@listen1954/board",
+  "version": "0.1.0",
+  "description": "Board for DeepSeek Harness: global and session scopes, natural-language tools, and a native Web UI.",
+  "author": "listen",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./client.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "client.d.ts"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/bundle-client.mjs",
+    "test": "tsc -p tsconfig.json && node --experimental-strip-types --test test/domain.test.ts test/store.test.ts test/isolation.test.ts test/service.test.ts test/wire.test.ts test/rpc.test.ts test/client-state.test.ts test/search.test.ts"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.8",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@types/node": "^22.20.1",
+    "@types/react": "~18.3.1",
+    "esbuild": "^0.25.0",
+    "react": "^18.2.0",
+    "typescript": "~5.9.0"
+  }
+}