@pcircle/footprint 1.5.0 → 1.7.0

package/dist/src/tools/get-session-trends.js

@@ -0,0 +1,130 @@
+import * as z from "zod";
+import { buildPageInfo, DEFAULT_SESSION_DETAIL_PAGE_LIMIT, MAX_SESSION_DETAIL_PAGE_LIMIT, } from "../lib/session-history.js";
+import { buildSessionTrendContext } from "../lib/session-trends.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { sessionDetailUiMetadata } from "./session-ui-metadata.js";
+const sessionHostEnum = z.enum(["claude", "gemini", "codex"]);
+const sessionStatusEnum = z.enum([
+    "running",
+    "completed",
+    "failed",
+    "interrupted",
+]);
+const pageInfoSchema = z.object({
+    total: z.number(),
+    offset: z.number(),
+    limit: z.number(),
+    returned: z.number(),
+    hasMore: z.boolean(),
+    nextOffset: z.number().nullable(),
+});
+export const getSessionTrendsSchema = {
+    inputSchema: {
+        id: z.string().describe("ID of the recorded session"),
+        limit: z
+            .number()
+            .int()
+            .positive()
+            .max(MAX_SESSION_DETAIL_PAGE_LIMIT)
+            .optional()
+            .describe(`Optional page size for the recurring trend slice. Defaults to ${DEFAULT_SESSION_DETAIL_PAGE_LIMIT}.`),
+        offset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Optional offset for the recurring trend slice."),
+    },
+    outputSchema: {
+        sessionId: z.string(),
+        summary: z.object({
+            totalTrends: z.number(),
+            crossSessionTrends: z.number(),
+            sessionAttempts: z.number(),
+            globalAttempts: z.number(),
+            otherSessions: z.number(),
+            activeBlockers: z.number(),
+            recoveredTrends: z.number(),
+            regressedTrends: z.number(),
+        }),
+        page: pageInfoSchema,
+        trends: z.array(z.object({
+            issueKey: z.string(),
+            label: z.string(),
+            kind: z.string().nullable(),
+            issueFamilyKey: z.string().nullable(),
+            issueFamilyLabel: z.string().nullable(),
+            relatedIssueKeys: z.array(z.string()),
+            blockerCategory: z.string(),
+            blockerState: z.enum(["active", "resolved"]),
+            remediationState: z.enum([
+                "unresolved",
+                "recovered",
+                "regressed",
+                "stable",
+            ]),
+            remediationSummary: z.string(),
+            lastSeenAt: z.string(),
+            latestFailureAt: z.string().nullable(),
+            latestSuccessAt: z.string().nullable(),
+            sessionCount: z.number(),
+            sessionAttempts: z.number(),
+            globalAttempts: z.number(),
+            sessionLatestOutcome: z.string(),
+            latestOutcome: z.string(),
+            hosts: z.array(sessionHostEnum),
+            statuses: z.array(sessionStatusEnum),
+            relatedSessionCount: z.number(),
+            relatedSessions: z.array(z.object({
+                sessionId: z.string(),
+                label: z.string(),
+                host: sessionHostEnum,
+                status: sessionStatusEnum,
+                lastAttemptAt: z.string(),
+                attempts: z.number(),
+                latestOutcome: z.string(),
+            })),
+        })),
+    },
+};
+export const getSessionTrendsMetadata = {
+    title: "Get Session Trends",
+    description: "Return paginated recurring trend context for a specific session, including related retries across other sessions.",
+    ...sessionDetailUiMetadata,
+};
+export function createGetSessionTrendsHandler(db) {
+    return wrapToolHandler("get-session-trends", "Use limit and offset to page through recurring session trends without reloading the full session detail payload.", async (params) => {
+        const session = db.findSessionById(params.id);
+        if (!session) {
+            throw new Error(`Session not found: ${params.id}`);
+        }
+        const limit = params.limit ?? DEFAULT_SESSION_DETAIL_PAGE_LIMIT;
+        const offset = params.offset ?? 0;
+        if (limit <= 0 || limit > MAX_SESSION_DETAIL_PAGE_LIMIT) {
+            throw new Error(`limit must be between 1 and ${MAX_SESSION_DETAIL_PAGE_LIMIT}`);
+        }
+        if (offset < 0) {
+            throw new Error("offset cannot be negative");
+        }
+        const trendContext = buildSessionTrendContext(db, params.id, {
+            limit,
+            offset,
+        });
+        const page = trendContext.page ??
+            buildPageInfo(trendContext.summary.totalTrends, trendContext.trends.length, { limit, offset });
+        return formatSuccessResponse("Session trends retrieved successfully", {
+            Session: params.id,
+            Trends: trendContext.trends.length,
+            Total: trendContext.summary.totalTrends,
+            Offset: offset,
+            Limit: limit,
+        }, {
+            sessionId: params.id,
+            summary: trendContext.summary,
+            page,
+            trends: trendContext.trends,
+        });
+    });
+}
+//# sourceMappingURL=get-session-trends.js.map

package/dist/src/tools/get-session-trends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-session-trends.js","sourceRoot":"","sources":["../../../src/tools/get-session-trends.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/get-session.d.ts

@@ -0,0 +1,251 @@
+import * as z from "zod";
+import type { EvidenceDatabase } from "../lib/storage/index.js";
+export declare const getSessionSchema: {
+    inputSchema: {
+        id: z.ZodString;
+        messageLimit: z.ZodOptional<z.ZodNumber>;
+        messageOffset: z.ZodOptional<z.ZodNumber>;
+        timelineLimit: z.ZodOptional<z.ZodNumber>;
+        timelineOffset: z.ZodOptional<z.ZodNumber>;
+        trendLimit: z.ZodOptional<z.ZodNumber>;
+        trendOffset: z.ZodOptional<z.ZodNumber>;
+    };
+    outputSchema: {
+        session: z.ZodObject<{
+            id: z.ZodString;
+            host: z.ZodEnum<{
+                claude: "claude";
+                gemini: "gemini";
+                codex: "codex";
+            }>;
+            title: z.ZodNullable<z.ZodString>;
+            label: z.ZodString;
+            status: z.ZodEnum<{
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                interrupted: "interrupted";
+            }>;
+            projectRoot: z.ZodString;
+            cwd: z.ZodString;
+            startedAt: z.ZodString;
+            endedAt: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        messageSummary: z.ZodObject<{
+            total: z.ZodNumber;
+            byRole: z.ZodObject<{
+                user: z.ZodNumber;
+                assistant: z.ZodNumber;
+                system: z.ZodNumber;
+            }, z.core.$strip>;
+            firstCapturedAt: z.ZodNullable<z.ZodString>;
+            lastCapturedAt: z.ZodNullable<z.ZodString>;
+            preview: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        timelineSummary: z.ZodObject<{
+            total: z.ZodNumber;
+            eventTypes: z.ZodArray<z.ZodString>;
+            statuses: z.ZodArray<z.ZodString>;
+            firstStartedAt: z.ZodNullable<z.ZodString>;
+            lastEndedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        messagePage: z.ZodObject<{
+            total: z.ZodNumber;
+            offset: z.ZodNumber;
+            limit: z.ZodNumber;
+            returned: z.ZodNumber;
+            hasMore: z.ZodBoolean;
+            nextOffset: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        timelinePage: z.ZodObject<{
+            total: z.ZodNumber;
+            offset: z.ZodNumber;
+            limit: z.ZodNumber;
+            returned: z.ZodNumber;
+            hasMore: z.ZodBoolean;
+            nextOffset: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        artifactSummary: z.ZodObject<{
+            total: z.ZodNumber;
+            byType: z.ZodObject<{
+                fileChange: z.ZodNumber;
+                commandOutput: z.ZodNumber;
+                testResult: z.ZodNumber;
+                gitCommit: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        trendContext: z.ZodObject<{
+            summary: z.ZodObject<{
+                totalTrends: z.ZodNumber;
+                crossSessionTrends: z.ZodNumber;
+                sessionAttempts: z.ZodNumber;
+                globalAttempts: z.ZodNumber;
+                otherSessions: z.ZodNumber;
+                activeBlockers: z.ZodNumber;
+                recoveredTrends: z.ZodNumber;
+                regressedTrends: z.ZodNumber;
+            }, z.core.$strip>;
+            page: z.ZodOptional<z.ZodObject<{
+                total: z.ZodNumber;
+                offset: z.ZodNumber;
+                limit: z.ZodNumber;
+                returned: z.ZodNumber;
+                hasMore: z.ZodBoolean;
+                nextOffset: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            trends: z.ZodArray<z.ZodObject<{
+                issueKey: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodNullable<z.ZodString>;
+                issueFamilyKey: z.ZodNullable<z.ZodString>;
+                issueFamilyLabel: z.ZodNullable<z.ZodString>;
+                relatedIssueKeys: z.ZodArray<z.ZodString>;
+                blockerCategory: z.ZodString;
+                blockerState: z.ZodEnum<{
+                    active: "active";
+                    resolved: "resolved";
+                }>;
+                remediationState: z.ZodEnum<{
+                    unresolved: "unresolved";
+                    recovered: "recovered";
+                    regressed: "regressed";
+                    stable: "stable";
+                }>;
+                remediationSummary: z.ZodString;
+                lastSeenAt: z.ZodString;
+                latestFailureAt: z.ZodNullable<z.ZodString>;
+                latestSuccessAt: z.ZodNullable<z.ZodString>;
+                sessionCount: z.ZodNumber;
+                sessionAttempts: z.ZodNumber;
+                globalAttempts: z.ZodNumber;
+                sessionLatestOutcome: z.ZodString;
+                latestOutcome: z.ZodString;
+                hosts: z.ZodArray<z.ZodEnum<{
+                    claude: "claude";
+                    gemini: "gemini";
+                    codex: "codex";
+                }>>;
+                statuses: z.ZodArray<z.ZodEnum<{
+                    running: "running";
+                    completed: "completed";
+                    failed: "failed";
+                    interrupted: "interrupted";
+                }>>;
+                relatedSessionCount: z.ZodNumber;
+                relatedSessions: z.ZodArray<z.ZodObject<{
+                    sessionId: z.ZodString;
+                    label: z.ZodString;
+                    host: z.ZodEnum<{
+                        claude: "claude";
+                        gemini: "gemini";
+                        codex: "codex";
+                    }>;
+                    status: z.ZodEnum<{
+                        running: "running";
+                        completed: "completed";
+                        failed: "failed";
+                        interrupted: "interrupted";
+                    }>;
+                    lastAttemptAt: z.ZodString;
+                    attempts: z.ZodNumber;
+                    latestOutcome: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sessionId: z.ZodString;
+            seq: z.ZodNumber;
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            source: z.ZodString;
+            content: z.ZodString;
+            capturedAt: z.ZodString;
+            metadata: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        timeline: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sessionId: z.ZodString;
+            seq: z.ZodNumber;
+            eventType: z.ZodString;
+            eventSubType: z.ZodNullable<z.ZodString>;
+            source: z.ZodString;
+            summary: z.ZodNullable<z.ZodString>;
+            payload: z.ZodNullable<z.ZodString>;
+            startedAt: z.ZodString;
+            endedAt: z.ZodNullable<z.ZodString>;
+            status: z.ZodNullable<z.ZodString>;
+            relatedMessageId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        hasNarratives: z.ZodBoolean;
+    };
+};
+export declare const getSessionMetadata: {
+    _meta: {
+        readonly ui: {
+            readonly resourceUri: "ui://footprint/session-detail.html";
+        };
+    };
+    title: string;
+    description: string;
+};
+export declare function createGetSessionHandler(db: EvidenceDatabase): (params: {
+    id: string;
+    messageLimit?: number;
+    messageOffset?: number;
+    timelineLimit?: number;
+    timelineOffset?: number;
+    trendLimit?: number;
+    trendOffset?: number;
+}) => Promise<import("../lib/tool-response.js").ToolResponse<{
+    session: {
+        id: string;
+        host: import("../lib/storage/types.js").SessionHost;
+        title: string | null;
+        label: string;
+        status: import("../lib/storage/types.js").SessionStatus;
+        projectRoot: string;
+        cwd: string;
+        startedAt: string;
+        endedAt: string | null;
+        metadata: string | null;
+    };
+    messageSummary: {
+        total: number;
+        byRole: {
+            user: number;
+            assistant: number;
+            system: number;
+        };
+        firstCapturedAt: string | null;
+        lastCapturedAt: string | null;
+        preview: string | null;
+    };
+    timelineSummary: {
+        total: number;
+        eventTypes: string[];
+        statuses: string[];
+        firstStartedAt: string | null;
+        lastEndedAt: string | null;
+    };
+    messagePage: import("../lib/session-history.js").PageInfo;
+    timelinePage: import("../lib/session-history.js").PageInfo;
+    artifactSummary: {
+        total: number;
+        byType: {
+            fileChange: number;
+            commandOutput: number;
+            testResult: number;
+            gitCommit: number;
+        };
+    };
+    trendContext: import("../lib/session-trends.js").SessionTrendContext;
+    messages: import("../lib/storage/types.js").SessionMessageRecord[];
+    timeline: import("../lib/storage/types.js").TimelineEventRecord[];
+    hasNarratives: boolean;
+}>>;
+//# sourceMappingURL=get-session.d.ts.map

package/dist/src/tools/get-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-session.d.ts","sourceRoot":"","sources":["../../../src/tools/get-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAWzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAkBhE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+K5B,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;CAK9B,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,gBAAgB;QAKlD,MAAM;mBACK,MAAM;oBACL,MAAM;oBACN,MAAM;qBACL,MAAM;iBACV,MAAM;kBACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8HzB"}

package/dist/src/tools/get-session.js

@@ -0,0 +1,290 @@
+import * as z from "zod";
+import { buildPageInfo, DEFAULT_SESSION_DETAIL_PAGE_LIMIT, getSessionLabel, MAX_SESSION_DETAIL_PAGE_LIMIT, truncateSummary, } from "../lib/session-history.js";
+import { buildSessionTrendContext } from "../lib/session-trends.js";
+import { formatSuccessResponse } from "../lib/tool-response.js";
+import { wrapToolHandler } from "../lib/tool-wrapper.js";
+import { sessionDetailUiMetadata } from "./session-ui-metadata.js";
+const sessionHostEnum = z.enum(["claude", "gemini", "codex"]);
+const sessionStatusEnum = z.enum([
+    "running",
+    "completed",
+    "failed",
+    "interrupted",
+]);
+const pageInfoSchema = z.object({
+    total: z.number(),
+    offset: z.number(),
+    limit: z.number(),
+    returned: z.number(),
+    hasMore: z.boolean(),
+    nextOffset: z.number().nullable(),
+});
+export const getSessionSchema = {
+    inputSchema: {
+        id: z.string().describe("ID of the recorded session to inspect"),
+        messageLimit: z
+            .number()
+            .int()
+            .positive()
+            .max(MAX_SESSION_DETAIL_PAGE_LIMIT)
+            .optional()
+            .describe("Optional page size for the initial transcript slice. Defaults to 50."),
+        messageOffset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Optional offset for the initial transcript slice."),
+        timelineLimit: z
+            .number()
+            .int()
+            .positive()
+            .max(MAX_SESSION_DETAIL_PAGE_LIMIT)
+            .optional()
+            .describe("Optional page size for the initial timeline slice. Defaults to 50."),
+        timelineOffset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Optional offset for the initial timeline slice."),
+        trendLimit: z
+            .number()
+            .int()
+            .positive()
+            .max(MAX_SESSION_DETAIL_PAGE_LIMIT)
+            .optional()
+            .describe("Optional page size for the initial recurring trend slice. Defaults to 50."),
+        trendOffset: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Optional offset for the initial recurring trend slice."),
+    },
+    outputSchema: {
+        session: z.object({
+            id: z.string(),
+            host: sessionHostEnum,
+            title: z.string().nullable(),
+            label: z.string(),
+            status: sessionStatusEnum,
+            projectRoot: z.string(),
+            cwd: z.string(),
+            startedAt: z.string(),
+            endedAt: z.string().nullable(),
+            metadata: z.string().nullable(),
+        }),
+        messageSummary: z.object({
+            total: z.number(),
+            byRole: z.object({
+                user: z.number(),
+                assistant: z.number(),
+                system: z.number(),
+            }),
+            firstCapturedAt: z.string().nullable(),
+            lastCapturedAt: z.string().nullable(),
+            preview: z.string().nullable(),
+        }),
+        timelineSummary: z.object({
+            total: z.number(),
+            eventTypes: z.array(z.string()),
+            statuses: z.array(z.string()),
+            firstStartedAt: z.string().nullable(),
+            lastEndedAt: z.string().nullable(),
+        }),
+        messagePage: pageInfoSchema,
+        timelinePage: pageInfoSchema,
+        artifactSummary: z.object({
+            total: z.number(),
+            byType: z.object({
+                fileChange: z.number(),
+                commandOutput: z.number(),
+                testResult: z.number(),
+                gitCommit: z.number(),
+            }),
+        }),
+        trendContext: z.object({
+            summary: z.object({
+                totalTrends: z.number(),
+                crossSessionTrends: z.number(),
+                sessionAttempts: z.number(),
+                globalAttempts: z.number(),
+                otherSessions: z.number(),
+                activeBlockers: z.number(),
+                recoveredTrends: z.number(),
+                regressedTrends: z.number(),
+            }),
+            page: pageInfoSchema.optional(),
+            trends: z.array(z.object({
+                issueKey: z.string(),
+                label: z.string(),
+                kind: z.string().nullable(),
+                issueFamilyKey: z.string().nullable(),
+                issueFamilyLabel: z.string().nullable(),
+                relatedIssueKeys: z.array(z.string()),
+                blockerCategory: z.string(),
+                blockerState: z.enum(["active", "resolved"]),
+                remediationState: z.enum([
+                    "unresolved",
+                    "recovered",
+                    "regressed",
+                    "stable",
+                ]),
+                remediationSummary: z.string(),
+                lastSeenAt: z.string(),
+                latestFailureAt: z.string().nullable(),
+                latestSuccessAt: z.string().nullable(),
+                sessionCount: z.number(),
+                sessionAttempts: z.number(),
+                globalAttempts: z.number(),
+                sessionLatestOutcome: z.string(),
+                latestOutcome: z.string(),
+                hosts: z.array(sessionHostEnum),
+                statuses: z.array(sessionStatusEnum),
+                relatedSessionCount: z.number(),
+                relatedSessions: z.array(z.object({
+                    sessionId: z.string(),
+                    label: z.string(),
+                    host: sessionHostEnum,
+                    status: sessionStatusEnum,
+                    lastAttemptAt: z.string(),
+                    attempts: z.number(),
+                    latestOutcome: z.string(),
+                })),
+            })),
+        }),
+        messages: z.array(z.object({
+            id: z.string(),
+            sessionId: z.string(),
+            seq: z.number(),
+            role: z.enum(["user", "assistant", "system"]),
+            source: z.string(),
+            content: z.string(),
+            capturedAt: z.string(),
+            metadata: z.string().nullable(),
+        })),
+        timeline: z.array(z.object({
+            id: z.string(),
+            sessionId: z.string(),
+            seq: z.number(),
+            eventType: z.string(),
+            eventSubType: z.string().nullable(),
+            source: z.string(),
+            summary: z.string().nullable(),
+            payload: z.string().nullable(),
+            startedAt: z.string(),
+            endedAt: z.string().nullable(),
+            status: z.string().nullable(),
+            relatedMessageId: z.string().nullable(),
+        })),
+        hasNarratives: z.boolean(),
+    },
+};
+export const getSessionMetadata = {
+    title: "Get Session",
+    description: "Inspect a recorded CLI session, including session metadata plus paginated transcript and timeline slices.",
+    ...sessionDetailUiMetadata,
+};
+export function createGetSessionHandler(db) {
+    return wrapToolHandler("get-session", "Verify the session ID exists and keep message/timeline pagination values within the allowed range before requesting details.", async (params) => {
+        const sessionRecord = db.findSessionById(params.id);
+        if (!sessionRecord) {
+            throw new Error(`Session not found: ${params.id}`);
+        }
+        const messageLimit = params.messageLimit ?? DEFAULT_SESSION_DETAIL_PAGE_LIMIT;
+        const messageOffset = params.messageOffset ?? 0;
+        const timelineLimit = params.timelineLimit ?? DEFAULT_SESSION_DETAIL_PAGE_LIMIT;
+        const timelineOffset = params.timelineOffset ?? 0;
+        const trendLimit = params.trendLimit ?? DEFAULT_SESSION_DETAIL_PAGE_LIMIT;
+        const trendOffset = params.trendOffset ?? 0;
+        if (messageLimit <= 0 || messageLimit > MAX_SESSION_DETAIL_PAGE_LIMIT) {
+            throw new Error(`messageLimit must be between 1 and ${MAX_SESSION_DETAIL_PAGE_LIMIT}`);
+        }
+        if (timelineLimit <= 0 || timelineLimit > MAX_SESSION_DETAIL_PAGE_LIMIT) {
+            throw new Error(`timelineLimit must be between 1 and ${MAX_SESSION_DETAIL_PAGE_LIMIT}`);
+        }
+        if (trendLimit <= 0 || trendLimit > MAX_SESSION_DETAIL_PAGE_LIMIT) {
+            throw new Error(`trendLimit must be between 1 and ${MAX_SESSION_DETAIL_PAGE_LIMIT}`);
+        }
+        if (messageOffset < 0) {
+            throw new Error("messageOffset cannot be negative");
+        }
+        if (timelineOffset < 0) {
+            throw new Error("timelineOffset cannot be negative");
+        }
+        if (trendOffset < 0) {
+            throw new Error("trendOffset cannot be negative");
+        }
+        const messageStats = db.getSessionMessageStats(params.id);
+        const timelineSummary = db.getSessionTimelineStats(params.id);
+        const messages = db.getSessionMessages(params.id, {
+            limit: messageLimit,
+            offset: messageOffset,
+        });
+        const timeline = db.getSessionTimeline(params.id, {
+            limit: timelineLimit,
+            offset: timelineOffset,
+        });
+        const artifactSummary = db.getSessionArtifactSummary(params.id);
+        const trendContext = buildSessionTrendContext(db, params.id, {
+            limit: trendLimit,
+            offset: trendOffset,
+        });
+        const hasNarratives = db.hasNarrativesForSession(params.id);
+        const session = {
+            id: sessionRecord.id,
+            host: sessionRecord.host,
+            title: sessionRecord.title,
+            label: getSessionLabel(sessionRecord),
+            status: sessionRecord.status,
+            projectRoot: sessionRecord.projectRoot,
+            cwd: sessionRecord.cwd,
+            startedAt: sessionRecord.startedAt,
+            endedAt: sessionRecord.endedAt,
+            metadata: sessionRecord.metadata,
+        };
+        const messageSummary = {
+            total: messageStats.total,
+            byRole: messageStats.byRole,
+            firstCapturedAt: messageStats.firstCapturedAt,
+            lastCapturedAt: messageStats.lastCapturedAt,
+            preview: messageStats.previewContent
+                ? truncateSummary(messageStats.previewContent)
+                : null,
+        };
+        const messagePage = buildPageInfo(messageStats.total, messages.length, {
+            offset: messageOffset,
+            limit: messageLimit,
+        });
+        const timelinePage = buildPageInfo(timelineSummary.total, timeline.length, {
+            offset: timelineOffset,
+            limit: timelineLimit,
+        });
+        return formatSuccessResponse("Session retrieved successfully", {
+            ID: sessionRecord.id,
+            Host: sessionRecord.host,
+            Status: sessionRecord.status,
+            Messages: messageSummary.total,
+            Events: timelineSummary.total,
+            MessagePage: `${messagePage.offset}-${messagePage.offset + messagePage.returned}`,
+            TimelinePage: `${timelinePage.offset}-${timelinePage.offset + timelinePage.returned}`,
+            TrendPage: `${trendContext.page?.offset ?? 0}-${(trendContext.page?.offset ?? 0) + (trendContext.page?.returned ?? trendContext.trends.length)}`,
+            Artifacts: artifactSummary.total,
+            RecurringTrends: trendContext.summary.totalTrends,
+            Narratives: hasNarratives ? "available" : "not generated",
+        }, {
+            session,
+            messageSummary,
+            timelineSummary,
+            messagePage,
+            timelinePage,
+            artifactSummary,
+            trendContext,
+            messages,
+            timeline,
+            hasNarratives,
+        });
+    });
+}
+//# sourceMappingURL=get-session.js.map