@nones/dsh-session-mcp 1.1.0 → 1.2.0

package/dist/client.js

@@ -2,8 +2,9 @@
 /**
  * dsh-session-mcp — Client half.
  *
- * Registers the MCP settings page: the live endpoint, the bearer token, and
- * copy-ready configuration blocks for every client this harness can serve.
+ * Registers the MCP settings page: live status, the last few requests, the
+ * endpoint, the bearer token, and copy-ready configuration blocks for every
+ * client this harness can serve.
  *
  * The page reads the config over the authenticated `/api` channel, so the token
  * never appears in the served HTML.
@@ -24,12 +25,25 @@ globalThis.__ModuleLoader__.load({
         const h = React.createElement;
         /** Locale namespace owned by this page. */
         const NS = 'dsh-session-mcp';
-        /** Where the Host publishes the live config. */
+        /** Where the Host publishes the live config, status and request journal. */
         const CONFIG_URL = '/api/dsh-session-mcp/config';
+        /** How often the page refreshes while open. */
+        const REFRESH_MS = 10000;
         const EN = {
             title: 'MCP',
             heading: 'MCP endpoint',
             description: 'Connect Claude Code, Codex, Cursor or any other MCP client to this harness. The endpoint starts together with the harness and requires the bearer token below.',
+            statusTitle: 'Status',
+            listening: 'Listening',
+            uptime: 'Uptime',
+            requests: 'Requests',
+            lastError: 'Last error',
+            logTitle: 'Recent requests',
+            logEmpty: 'No requests yet. Connect a client and call a tool.',
+            colTime: 'Time',
+            colTool: 'Request',
+            colSession: 'Conversation',
+            colResult: 'Result',
             endpoint: 'Endpoint',
             bearer: 'Bearer token',
             show: 'Show',
@@ -42,11 +56,24 @@ globalThis.__ModuleLoader__.load({
             note: 'Paste any block into your client. The token is stable across restarts; it rotates only when you delete $DSH_HOME/state/dsh-session-mcp.json and restart the harness.',
             loading: 'Loading…',
             error: 'Could not read the endpoint config: ',
+            noSession: '—',
+            failed: 'error',
         };
         const RU = {
             title: 'MCP',
             heading: 'MCP-эндпоинт',
             description: 'Подключите Claude Code, Codex, Cursor или любой другой MCP-клиент к этому харнесу. Эндпоинт поднимается вместе с харнесом и требует Bearer-токен ниже.',
+            statusTitle: 'Статус',
+            listening: 'Слушает',
+            uptime: 'В работе',
+            requests: 'Запросов',
+            lastError: 'Последняя ошибка',
+            logTitle: 'Последние запросы',
+            logEmpty: 'Запросов пока нет. Подключите клиент и вызовите инструмент.',
+            colTime: 'Время',
+            colTool: 'Запрос',
+            colSession: 'Сессия',
+            colResult: 'Результат',
             endpoint: 'Эндпоинт',
             bearer: 'Bearer-токен',
             show: 'Показать',
@@ -59,6 +86,8 @@ globalThis.__ModuleLoader__.load({
             note: 'Вставьте любой блок в свой клиент. Токен не меняется между перезапусками; он обновится только если удалить $DSH_HOME/state/dsh-session-mcp.json и перезапустить харнес.',
             loading: 'Загрузка…',
             error: 'Не удалось прочитать конфиг эндпоинта: ',
+            noSession: '—',
+            failed: 'ошибка',
         };
         /** Theme-bound inline styles; no colors are hardcoded. */
         const styles = {
@@ -112,6 +141,40 @@ globalThis.__ModuleLoader__.load({
                 color: 'var(--dsw-alias-label-primary)',
                 cursor: 'pointer',
             },
+            pillOk: {
+                display: 'inline-block',
+                padding: '1px 9px',
+                borderRadius: '999px',
+                fontSize: '11px',
+                border: '1px solid var(--dsw-alias-state-success-primary)',
+                color: 'var(--dsw-alias-state-success-primary)',
+                whiteSpace: 'nowrap',
+            },
+            pillError: {
+                display: 'inline-block',
+                padding: '1px 9px',
+                borderRadius: '999px',
+                fontSize: '11px',
+                border: '1px solid var(--dsw-alias-state-error-primary)',
+                color: 'var(--dsw-alias-state-error-primary)',
+                whiteSpace: 'nowrap',
+            },
+            table: { width: '100%', borderCollapse: 'collapse', fontSize: '12px' },
+            th: {
+                textAlign: 'left',
+                fontWeight: 600,
+                color: 'var(--dsw-alias-label-secondary)',
+                padding: '0 8px 6px 0',
+                borderBottom: '1px solid var(--dsw-alias-border-l1)',
+                whiteSpace: 'nowrap',
+            },
+            td: {
+                padding: '6px 8px 6px 0',
+                borderBottom: '1px solid var(--dsw-alias-border-l1)',
+                verticalAlign: 'top',
+            },
+            mono: { fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace' },
+            muted: { color: 'var(--dsw-alias-label-secondary)' },
             pre: {
                 margin: 0,
                 padding: '12px',
@@ -128,6 +191,24 @@ globalThis.__ModuleLoader__.load({
             note: { margin: 0, color: 'var(--dsw-alias-label-secondary)', fontSize: '12px' },
             error: { margin: 0, color: 'var(--dsw-alias-state-error-primary)' },
         };
+        /** `45s`, `12m 3s`, `1h 12m`. */
+        function formatUptime(ms) {
+            const total = Math.max(0, Math.floor(ms / 1000));
+            if (total < 60)
+                return `${String(total)}s`;
+            const minutes = Math.floor(total / 60);
+            if (minutes < 60)
+                return `${String(minutes)}m ${String(total % 60)}s`;
+            const hours = Math.floor(minutes / 60);
+            if (hours < 24)
+                return `${String(hours)}h ${String(minutes % 60)}m`;
+            return `${String(Math.floor(hours / 24))}d ${String(hours % 24)}h`;
+        }
+        /** Local wall-clock time for one ISO timestamp. */
+        function formatTime(iso) {
+            const date = new Date(iso);
+            return Number.isNaN(date.getTime()) ? iso : date.toLocaleTimeString();
+        }
         return {
             inject: ['slots', 'locale'],
             apply(ctx) {
@@ -155,24 +236,49 @@ globalThis.__ModuleLoader__.load({
                 function Snippet(props) {
                     return h('section', { style: styles.card }, h('div', { style: styles.cardHead }, h('span', { style: styles.cardTitle }, props.title), h(CopyButton, { text: props.text })), h('pre', { style: styles.pre }, props.text));
                 }
+                function StatusCard(props) {
+                    const status = props.status;
+                    const failure = status.lastFailure;
+                    return h('section', { style: styles.card }, h('div', { style: styles.cardHead }, h('span', { style: styles.cardTitle }, t('statusTitle')), h('span', { style: styles.pillOk }, t('listening'))), h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('uptime')), h('span', { style: styles.rowValue }, formatUptime(Number(status.uptimeMs)))), h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('requests')), h('span', { style: styles.rowValue }, String(status.totalCalls))), failure === null || failure === undefined
+                        ? null
+                        : h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('lastError')), h('span', { style: { ...styles.rowValue, color: 'var(--dsw-alias-state-error-primary)' } }, `${String(failure.tool)} · ${formatTime(String(failure.at))} · ${String(failure.message)}`)));
+                }
+                function LogCard(props) {
+                    const entries = props.entries ?? [];
+                    const head = h('div', { style: styles.cardHead }, h('span', { style: styles.cardTitle }, t('logTitle')), h('span', { style: styles.muted }, String(entries.length)));
+                    if (entries.length === 0) {
+                        return h('section', { style: styles.card }, head, h('p', { style: styles.note }, t('logEmpty')));
+                    }
+                    const rows = entries.map((entry) => h('tr', { key: String(entry.id) }, h('td', { style: { ...styles.td, ...styles.mono, whiteSpace: 'nowrap' } }, formatTime(String(entry.at))), h('td', { style: { ...styles.td, ...styles.mono } }, String(entry.tool)), h('td', { style: styles.td }, entry.sessionId === null
+                        ? h('span', { style: styles.muted }, t('noSession'))
+                        : h('span', { title: String(entry.sessionId) }, String(entry.sessionTitle ?? `${String(entry.sessionId).slice(0, 14)}…`))), h('td', { style: { ...styles.td, whiteSpace: 'nowrap' } }, entry.ok
+                        ? h('span', { style: styles.pillOk }, `ok · ${String(entry.ms)}ms`)
+                        : h('span', { style: styles.pillError, title: String(entry.error ?? '') }, t('failed')))));
+                    return h('section', { style: styles.card }, head, h('table', { style: styles.table }, h('thead', null, h('tr', null, h('th', { style: styles.th }, t('colTime')), h('th', { style: styles.th }, t('colTool')), h('th', { style: styles.th }, t('colSession')), h('th', { style: styles.th }, t('colResult')))), h('tbody', null, rows)));
+                }
                 function Section() {
                     useLocaleRevision();
                     const [state, setState] = React.useState({ status: 'loading' });
                     const [revealed, setRevealed] = React.useState(false);
                     React.useEffect(() => {
                         let alive = true;
-                        g.fetch(CONFIG_URL, { headers: { accept: 'application/json' }, credentials: 'same-origin' })
-                            .then((response) => response.ok ? response.json() : Promise.reject(new Error(`HTTP ${String(response.status)}`)))
-                            .then((data) => {
-                            if (alive)
-                                setState({ status: 'ready', data });
-                        })
-                            .catch((error) => {
-                            if (alive)
-                                setState({ status: 'error', message: String(error?.message ?? error) });
-                        });
+                        const load = () => {
+                            g.fetch(CONFIG_URL, { headers: { accept: 'application/json' }, credentials: 'same-origin' })
+                                .then((response) => response.ok ? response.json() : Promise.reject(new Error(`HTTP ${String(response.status)}`)))
+                                .then((data) => {
+                                if (alive)
+                                    setState({ status: 'ready', data });
+                            })
+                                .catch((error) => {
+                                if (alive)
+                                    setState({ status: 'error', message: String(error?.message ?? error) });
+                            });
+                        };
+                        load();
+                        const timer = g.setInterval(load, REFRESH_MS);
                         return () => {
                             alive = false;
+                            g.clearInterval(timer);
                         };
                     }, []);
                     const header = h('div', { style: { display: 'grid', gap: '4px' } }, h('h2', { style: styles.heading }, t('heading')), h('p', { style: styles.description }, t('description')));
@@ -185,7 +291,7 @@ globalThis.__ModuleLoader__.load({
                     const data = state.data;
                     const token = String(data.token);
                     const masked = `${token.slice(0, 6)}…${token.slice(-4)}`;
-                    return h('div', { style: styles.page }, header, h('section', { style: styles.card }, h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('endpoint')), h('span', { style: styles.rowValue }, data.url), h('div', { style: styles.actions }, h(CopyButton, { text: data.url }))), h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('bearer')), h('span', { style: styles.rowValue }, revealed ? token : masked), h('div', { style: styles.actions }, h('button', {
+                    return h('div', { style: styles.page }, header, h(StatusCard, { status: data.status }), h(LogCard, { entries: data.log ?? [] }), h('section', { style: styles.card }, h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('endpoint')), h('span', { style: styles.rowValue }, data.url), h('div', { style: styles.actions }, h(CopyButton, { text: data.url }))), h('div', { style: styles.row }, h('span', { style: styles.rowLabel }, t('bearer')), h('span', { style: styles.rowValue }, revealed ? token : masked), h('div', { style: styles.actions }, h('button', {
                         type: 'button',
                         style: styles.button,
                         onClick: () => setRevealed((value) => !value),

package/dist/config.d.ts

@@ -93,6 +93,31 @@ export interface ConfigSnippets {
  * @returns the three snippets the Settings page shows.
  */
 export declare function snippetsFor(url: string, token: string): ConfigSnippets;
+/** Live health of the MCP endpoint, as the Settings page shows it. */
+export interface StatusPayload {
+    /** `listening` while the plugin serves; the page never renders a dead endpoint as healthy. */
+    readonly state: 'listening';
+    readonly version: string;
+    readonly startedAt: string;
+    readonly uptimeMs: number;
+    readonly totalCalls: number;
+    readonly lastFailure: {
+        readonly at: string;
+        readonly tool: string;
+        readonly message: string;
+    } | null;
+}
+/** One journalled call with the conversation title resolved for display. */
+export interface LogEntry {
+    readonly id: number;
+    readonly tool: string;
+    readonly at: string;
+    readonly sessionId: string | null;
+    readonly sessionTitle: string | null;
+    readonly ok: boolean;
+    readonly ms: number;
+    readonly error?: string;
+}
 /** What the Settings page receives from the Host. */
 export interface ConfigPayload {
     readonly name: string;
@@ -102,4 +127,6 @@ export interface ConfigPayload {
     readonly token: string;
     readonly updatedAt: string;
     readonly snippets: ConfigSnippets;
+    readonly status: StatusPayload;
+    readonly log: readonly LogEntry[];
 }

package/dist/index.js

@@ -14,6 +14,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { clientConfig, CONFIG_ROUTE_PATH, createToken, DEFAULT_HOST, DEFAULT_PORT, readState, SERVER_NAME, snippetsFor, writeState, } from './config.js';
+import { RequestJournal } from './log.js';
 import { startEndpoint } from './server.js';
 /** Stable Cordis plugin name. */
 export const name = 'dsh-session-mcp';
@@ -61,6 +62,7 @@ export async function apply(ctx, config) {
     const stored = readState();
     const token = stored?.token ?? createToken();
     const createdAt = stored?.createdAt ?? new Date().toISOString();
+    const journal = new RequestJournal();
     const endpoint = await startEndpoint({
         controller: ctx.sessionController,
         token,
@@ -68,6 +70,7 @@ export async function apply(ctx, config) {
         port,
         version,
         logger: ctx.logger,
+        journal,
     });
     const state = {
         version: 1,
@@ -85,23 +88,59 @@ export async function apply(ctx, config) {
     ctx.logger?.info?.(`dsh-session-mcp: bearer token and client config in ${file}`);
     console.log(`dsh-session-mcp: ${endpoint.url} (bearer in ${file})`);
     console.log(JSON.stringify(state.client, null, 2));
+    /** Resolve conversation titles for the journalled calls, best effort. */
+    const titlesFor = async (ids) => {
+        const titles = new Map();
+        if (ids.length === 0)
+            return titles;
+        try {
+            const rows = await ctx.sessionController.list({}, new AbortController().signal);
+            for (const row of rows?.items ?? []) {
+                if (ids.includes(row.sessionId))
+                    titles.set(row.sessionId, row.projections?.values?.title ?? null);
+            }
+        }
+        catch {
+            /* Titles decorate the log; a failed lookup must not fail the page. */
+        }
+        return titles;
+    };
+    /** Build the Settings payload fresh on every read. */
+    const buildPayload = async () => {
+        const records = journal.snapshot();
+        const ids = [...new Set(records.map((entry) => entry.sessionId).filter((id) => id !== null))];
+        const titles = await titlesFor(ids);
+        const log = records.map((entry) => ({
+            ...entry,
+            sessionTitle: entry.sessionId === null ? null : (titles.get(entry.sessionId) ?? null),
+        }));
+        return {
+            name: SERVER_NAME,
+            url: endpoint.url,
+            host,
+            port: endpoint.port,
+            token,
+            updatedAt: state.updatedAt,
+            snippets: snippetsFor(endpoint.url, token),
+            status: {
+                state: 'listening',
+                version,
+                startedAt: journal.startedAtIso,
+                uptimeMs: Date.now() - Date.parse(journal.startedAtIso),
+                totalCalls: journal.totalCalls,
+                lastFailure: journal.lastFailure,
+            },
+            log,
+        };
+    };
     // The Settings page reads the live config over the authenticated `/api`
     // channel, so the token never enters the served HTML.
-    const payload = {
-        name: SERVER_NAME,
-        url: endpoint.url,
-        host,
-        port: endpoint.port,
-        token,
-        updatedAt: state.updatedAt,
-        snippets: snippetsFor(endpoint.url, token),
-    };
     ctx.inject(['connection'], (connectionCtx) => {
         connectionCtx.connection.fetch.register({
             path: CONFIG_ROUTE_PATH,
             methods: ['GET'],
             requestBody: 'buffered',
-            fetch: async () => new Response(JSON.stringify(payload), {
+            fetch: async () => new Response(JSON.stringify(await buildPayload()), {
                 status: 200,
                 headers: {
                     'content-type': 'application/json; charset=utf-8',

package/dist/log.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Bounded request journal for the MCP endpoint.
+ *
+ * Only the last few tool calls are kept: enough for the Settings page to answer
+ * "what just happened, and which conversation did it touch", without turning the
+ * plugin into a log store.
+ *
+ * @module dsh-session-mcp/log
+ */
+/** How many calls the journal keeps. */
+export declare const MAX_RECORDS = 5;
+/** One completed tool call. */
+export interface RequestRecord {
+    /** Monotonic id, so the page can key rows. */
+    readonly id: number;
+    /** Wire tool name, for example `session_send`. */
+    readonly tool: string;
+    /** ISO timestamp of completion. */
+    readonly at: string;
+    /** Conversation the call addressed, when it addressed one. */
+    readonly sessionId: string | null;
+    /** Whether the tool answered without `isError`. */
+    readonly ok: boolean;
+    /** Wall-clock duration in milliseconds. */
+    readonly ms: number;
+    /** Failure text for a failed call. */
+    readonly error?: string;
+}
+/** The failure the page surfaces in its status card. */
+export interface LastFailure {
+    readonly at: string;
+    readonly tool: string;
+    readonly message: string;
+}
+/** The journal itself. */
+export declare class RequestJournal {
+    private readonly records;
+    private total;
+    private failure;
+    private readonly startedAt;
+    /**
+     * Append one completed call, dropping the oldest beyond {@link MAX_RECORDS}.
+     * @param entry - everything but the id, which this method assigns.
+     */
+    record(entry: Omit<RequestRecord, 'id'>): void;
+    /** @returns the newest-first snapshot the Settings page renders. */
+    snapshot(): readonly RequestRecord[];
+    /** @returns how many calls this endpoint served since it started. */
+    get totalCalls(): number;
+    /** @returns the most recent failure, or `null` when everything succeeded. */
+    get lastFailure(): LastFailure | null;
+    /** @returns the ISO timestamp this endpoint started listening. */
+    get startedAtIso(): string;
+}

package/dist/log.js

@@ -0,0 +1,51 @@
+/**
+ * Bounded request journal for the MCP endpoint.
+ *
+ * Only the last few tool calls are kept: enough for the Settings page to answer
+ * "what just happened, and which conversation did it touch", without turning the
+ * plugin into a log store.
+ *
+ * @module dsh-session-mcp/log
+ */
+/** How many calls the journal keeps. */
+export const MAX_RECORDS = 5;
+/** The journal itself. */
+export class RequestJournal {
+    records = [];
+    total = 0;
+    failure = null;
+    startedAt = new Date().toISOString();
+    /**
+     * Append one completed call, dropping the oldest beyond {@link MAX_RECORDS}.
+     * @param entry - everything but the id, which this method assigns.
+     */
+    record(entry) {
+        this.total += 1;
+        this.records.unshift({ id: this.total, ...entry });
+        if (this.records.length > MAX_RECORDS)
+            this.records.length = MAX_RECORDS;
+        if (!entry.ok) {
+            this.failure = {
+                at: entry.at,
+                tool: entry.tool,
+                message: entry.error ?? 'the tool reported an error',
+            };
+        }
+    }
+    /** @returns the newest-first snapshot the Settings page renders. */
+    snapshot() {
+        return [...this.records];
+    }
+    /** @returns how many calls this endpoint served since it started. */
+    get totalCalls() {
+        return this.total;
+    }
+    /** @returns the most recent failure, or `null` when everything succeeded. */
+    get lastFailure() {
+        return this.failure;
+    }
+    /** @returns the ISO timestamp this endpoint started listening. */
+    get startedAtIso() {
+        return this.startedAt;
+    }
+}

package/dist/server.d.ts

@@ -1,3 +1,4 @@
+import type { RequestJournal } from './log.js';
 import type { PluginLogger, SessionController } from './types.js';
 /** Path the MCP endpoint answers on. */
 export declare const MCP_PATH = "/mcp";
@@ -17,6 +18,7 @@ export interface StartEndpointOptions {
     readonly port: number;
     readonly version: string;
     readonly logger?: PluginLogger | undefined;
+    readonly journal?: RequestJournal | undefined;
 }
 /**
  * Build the web-standard MCP handler for one session controller.
@@ -24,7 +26,7 @@ export interface StartEndpointOptions {
  * @param version - advertised server version.
  * @returns an object exposing `fetch(Request)`.
  */
-export declare function buildMcpHandler(controller: SessionController, version: string): import("@modelcontextprotocol/server").McpHttpHandler;
+export declare function buildMcpHandler(controller: SessionController, version: string, journal?: RequestJournal): import("@modelcontextprotocol/server").McpHttpHandler;
 /**
  * Start the bearer-authenticated MCP endpoint.
  * @param options - controller, token, host, port, version, logger.

package/dist/server.js

@@ -32,10 +32,10 @@ const LOOPBACK = new Set(['127.0.0.1', '::1', 'localhost', '[::1]']);
  * @param version - advertised server version.
  * @returns an object exposing `fetch(Request)`.
  */
-export function buildMcpHandler(controller, version) {
+export function buildMcpHandler(controller, version, journal) {
     return createMcpHandler(() => {
         const server = new McpServer({ name: SERVER_NAME, version }, { instructions: SERVER_INSTRUCTIONS });
-        registerTools(server, controller);
+        registerTools(server, controller, journal);
         return server;
     });
 }
@@ -110,8 +110,8 @@ async function bind(server, port, host) {
  * @returns the resolved endpoint plus a disposer.
  */
 export async function startEndpoint(options) {
-    const { controller, token, host, port, version, logger } = options;
-    const handler = buildMcpHandler(controller, version);
+    const { controller, token, host, port, version, logger, journal } = options;
+    const handler = buildMcpHandler(controller, version, journal);
     const nodeHandler = toNodeHandler(handler);
     const server = createServer((req, res) => {
         if (!hostIsLoopback(req)) {

package/dist/tools.d.ts

@@ -1,8 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/server';
+import type { RequestJournal } from './log.js';
 import type { SessionController } from './types.js';
 /**
  * Register the session tools on one MCP server instance.
  * @param server - a fresh `McpServer` for one serving unit.
  * @param controller - the Harness `sessionController` service.
+ * @param journal - bounded request journal the Settings page reads.
  */
-export declare function registerTools(server: McpServer, controller: SessionController): void;
+export declare function registerTools(server: McpServer, controller: SessionController, journal?: RequestJournal): void;

package/dist/tools.js

@@ -6,6 +6,9 @@
  * the session log (which is what a `dsh --profile sdk`/`acp` resume of a live
  * session would collide with).
  *
+ * Each call is journalled so the Settings page can show what just happened and
+ * which conversation it touched.
+ *
  * @module dsh-session-mcp/tools
  */
 import { randomUUID } from 'node:crypto';
@@ -80,19 +83,66 @@ function fail(error) {
     const message = error instanceof Error ? error.message : String(error);
     return { content: [{ type: 'text', text: message }], isError: true };
 }
+/** First text block of a result, for the journal's failure line. */
+function firstText(result) {
+    const block = result.content?.[0];
+    return typeof block?.text === 'string' ? block.text.slice(0, 400) : 'the tool reported an error';
+}
+/** Read the created conversation id out of a `session_create` result. */
+function createdSessionId(result) {
+    try {
+        const raw = result.content?.[0]?.text;
+        const parsed = JSON.parse(typeof raw === 'string' ? raw : '');
+        if (parsed !== null && typeof parsed === 'object') {
+            const id = parsed.sessionId;
+            if (typeof id === 'string')
+                return id;
+        }
+    }
+    catch {
+        /* A malformed result is already the caller's error. */
+    }
+    return null;
+}
 /**
  * Register the session tools on one MCP server instance.
  * @param server - a fresh `McpServer` for one serving unit.
  * @param controller - the Harness `sessionController` service.
+ * @param journal - bounded request journal the Settings page reads.
  */
-export function registerTools(server, controller) {
+export function registerTools(server, controller, journal) {
+    /**
+     * Run one handler and journal the outcome.
+     * @param tool - wire tool name.
+     * @param run - the handler body.
+     * @param fromResult - whether the addressed conversation comes from the result.
+     */
+    const tracked = (tool, run, fromResult = false) => {
+        return async (args) => {
+            const started = Date.now();
+            const result = await run(args);
+            if (journal !== undefined) {
+                const failed = result.isError === true;
+                const addressed = typeof args?.sessionId === 'string' ? args.sessionId : fromResult ? createdSessionId(result) : null;
+                journal.record({
+                    tool,
+                    at: new Date().toISOString(),
+                    sessionId: addressed,
+                    ok: !failed,
+                    ms: Date.now() - started,
+                    ...(failed ? { error: firstText(result) } : {}),
+                });
+            }
+            return result;
+        };
+    };
     server.registerTool('sessions_list', {
         title: 'List conversations',
         description: 'List DeepSeek Harness conversations with id, title, working directory, running state and token usage. Call this first to discover the sessionId to read or prompt.',
         inputSchema: z.object({
             limit: z.number().int().min(1).max(500).optional().describe('Maximum rows, newest first. Default 50.'),
         }),
-    }, async ({ limit }) => {
+    }, tracked('sessions_list', async ({ limit }) => {
         try {
             const value = await controller.list({}, never());
             const rows = [...(value?.items ?? [])]
@@ -113,7 +163,7 @@ export function registerTools(server, controller) {
         catch (error) {
             return fail(error);
         }
-    });
+    }));
     server.registerTool('session_read', {
         title: 'Read conversation history',
         description: 'Read durable history of one conversation (user, assistant and tool messages). Use beforeSeq to page further back.',
@@ -122,7 +172,7 @@ export function registerTools(server, controller) {
             maxMessages: z.number().int().min(1).max(200).optional().describe('Roughly how many messages. Default 20.'),
             beforeSeq: z.number().int().min(0).optional().describe('Only return events before this sequence number.'),
         }),
-    }, async ({ sessionId, maxMessages, beforeSeq }) => {
+    }, tracked('session_read', async ({ sessionId, maxMessages, beforeSeq }) => {
         try {
             const rows = await controller.list({}, never());
             const cut = (rows?.items ?? []).find((item) => item.sessionId === sessionId)?.projections?.asOfSeq;
@@ -144,7 +194,7 @@ export function registerTools(server, controller) {
         catch (error) {
             return fail(error);
         }
-    });
+    }));
     server.registerTool('session_send', {
         title: 'Send a message into a conversation',
         description: 'Send a user message into an existing conversation. The message joins the live chat a human sees and starts a model turn. mode=queue waits for the current turn, mode=steer interrupts into it.',
@@ -153,7 +203,7 @@ export function registerTools(server, controller) {
             text: z.string().min(1).describe('Message text to deliver.'),
             mode: z.enum(['queue', 'steer']).optional().describe('Delivery mode. Default queue.'),
         }),
-    }, async ({ sessionId, text, mode }) => {
+    }, tracked('session_send', async ({ sessionId, text, mode }) => {
         try {
             if (text.trim().length === 0)
                 throw new Error('text must contain non-whitespace content');
@@ -165,7 +215,7 @@ export function registerTools(server, controller) {
         catch (error) {
             return fail(error);
         }
-    });
+    }));
     server.registerTool('session_create', {
         title: 'Open a new conversation',
         description: 'Open a new blank conversation in the Harness and return its id. Combine with session_send to start work in a fresh chat.',
@@ -173,7 +223,7 @@ export function registerTools(server, controller) {
             cwd: z.string().min(1).optional().describe('Absolute directory the conversation works in.'),
             agentPreset: z.string().min(1).optional().describe('Agent preset name. Omit for the configured default.'),
         }),
-    }, async ({ cwd, agentPreset }) => {
+    }, tracked('session_create', async ({ cwd, agentPreset }) => {
         try {
             const request = {};
             if (cwd !== undefined)
@@ -186,14 +236,14 @@ export function registerTools(server, controller) {
         catch (error) {
             return fail(error);
         }
-    });
+    }, true));
     server.registerTool('session_search', {
         title: 'Search conversations',
         description: 'Full-text search across conversations. Works only when the Harness has the session-query index enabled; otherwise the Host reports that search is disabled.',
         inputSchema: z.object({
             query: z.string().min(1).describe('Search text.'),
         }),
-    }, async ({ query }) => {
+    }, tracked('session_search', async ({ query }) => {
         try {
             const value = await controller.search({ query }, never());
             return ok({ items: value?.items ?? [], hasMore: value?.hasMore === true });
@@ -201,5 +251,5 @@ export function registerTools(server, controller) {
         catch (error) {
             return fail(error);
         }
-    });
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nones/dsh-session-mcp",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP server for DeepSeek Harness sessions — list, read and prompt live conversations from any MCP client",
   "type": "module",
   "license": "MIT",