pulseed 0.6.2 → 0.6.4

package/dist/interface/chat/chat-history.js

@@ -4,7 +4,7 @@
 // Persists via StateManager.writeRaw (persist-before-execute principle).
 import { z } from "zod";
 import { RuntimeReplyTargetSchema } from "../../runtime/session-registry/types.js";
-import { redactSetupSecrets, SetupSecretIntakeItemSchema } from "./setup-secret-intake.js";
+import { redactSetupSecrets, redactSetupSecretsDeep, SetupSecretIntakeItemSchema } from "./setup-secret-intake.js";
 import { SetupDialoguePublicStateSchema } from "./setup-dialogue.js";
 import { RunSpecSchema } from "../../runtime/run-spec/index.js";
 // ─── Schemas ───
@@ -35,6 +35,77 @@ export const ChatSessionUsageSchema = z.object({
     byPhase: z.record(ChatUsageCounterSchema).default({}),
     updatedAt: z.string().optional(),
 }).passthrough();
+export const ChatTurnContextSnapshotSchema = z.object({
+    schema_version: z.string(),
+    modelVisible: z.unknown(),
+}).passthrough();
+export const ChatRolloutJournalRecordKindSchema = z.enum([
+    "user_input",
+    "turn_context",
+    "model_output",
+    "tool_call",
+    "tool_result",
+    "permission_decision",
+    "display_event",
+    "completion_state",
+]);
+export const ChatRolloutJournalRecordSchema = z.object({
+    schema_version: z.literal("chat-rollout-journal-record-v1"),
+    id: z.string(),
+    sessionId: z.string(),
+    runId: z.string().nullable(),
+    turnId: z.string().nullable(),
+    sequence: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    kind: ChatRolloutJournalRecordKindSchema,
+    source: z.enum(["chat_history", "chat_event", "agent_timeline", "approval_store"]).default("chat_history"),
+    visibility: z.enum(["model_visible", "display", "debug", "host_only"]),
+    payload: z.unknown(),
+}).passthrough();
+export const CHAT_COMPACTION_RECORD_SCHEMA_VERSION = "chat-compaction-record-v1";
+export const ChatCompactionRecordSchema = z.object({
+    schema_version: z.literal(CHAT_COMPACTION_RECORD_SCHEMA_VERSION),
+    id: z.string(),
+    sessionId: z.string(),
+    sequence: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    reason: z.enum(["manual_command", "auto_context_limit"]).default("manual_command"),
+    inputMessageCount: z.number().int().nonnegative(),
+    outputMessageCount: z.number().int().nonnegative(),
+    removedMessageCount: z.number().int().nonnegative(),
+    retainedMessageCount: z.number().int().nonnegative(),
+    summary: z.string(),
+    modelVisibleSummary: z.string(),
+    archivedUserMessages: z.array(ChatMessageSchema),
+    archivedAssistantMessages: z.array(ChatMessageSchema),
+    retainedMessages: z.array(ChatMessageSchema),
+    pendingPermissions: z.array(z.object({
+        sequence: z.number().int().nonnegative(),
+        source: z.string(),
+        status: z.enum(["requested", "resolved", "unknown"]),
+        invalidatedByCompaction: z.boolean(),
+        payload: z.unknown(),
+    }).passthrough()),
+    decisions: z.array(z.object({
+        sequence: z.number().int().nonnegative(),
+        kind: ChatRolloutJournalRecordKindSchema,
+        source: z.string(),
+        visibility: z.string(),
+        payload: z.unknown(),
+    }).passthrough()),
+    activeTargets: z.array(z.object({
+        source: z.string(),
+        state: z.enum(["retained", "session"]),
+        payload: z.unknown(),
+    }).passthrough()),
+    replacementHistory: z.object({
+        removedTurnIndexes: z.array(z.number().int().nonnegative()),
+        retainedOriginalTurnIndexes: z.array(z.number().int().nonnegative()),
+        rewrittenTurnIndexes: z.array(z.number().int().nonnegative()),
+        rolloutJournalSequences: z.array(z.number().int().nonnegative()),
+        turnContextCount: z.number().int().nonnegative(),
+    }).passthrough(),
+}).passthrough();
 export const RunSpecConfirmationStateSchema = z.object({
     state: z.enum(["pending", "confirmed", "cancelled"]),
     spec: RunSpecSchema,
@@ -73,11 +144,14 @@ export const ChatSessionSchema = z.object({
     runSpecConfirmation: RunSpecConfirmationStateSchema.nullable().optional(),
     messages: z.array(ChatMessageSchema),
     compactionSummary: z.string().optional(),
+    compactionRecords: z.array(ChatCompactionRecordSchema).optional(),
     agentLoopStatePath: z.string().nullable().optional(),
     agentLoopStatus: z.enum(["running", "completed", "failed"]).nullable().optional(),
     agentLoopResumable: z.boolean().nullable().optional(),
     agentLoopUpdatedAt: z.string().nullable().optional(),
     agentLoop: ChatSessionAgentLoopMetadataSchema.optional(),
+    turnContexts: z.array(ChatTurnContextSnapshotSchema).optional(),
+    rolloutJournal: z.array(ChatRolloutJournalRecordSchema).optional(),
     usage: ChatSessionUsageSchema.optional(),
 }).passthrough();
 // ─── ChatHistory ───
@@ -95,6 +169,9 @@ export class ChatHistory {
                 cwd: existingSession.cwd,
                 updatedAt: existingSession.updatedAt ?? existingSession.createdAt,
                 messages: [...existingSession.messages],
+                ...(existingSession.compactionRecords ? { compactionRecords: cloneCompactionRecords(existingSession.compactionRecords) } : {}),
+                ...(existingSession.turnContexts ? { turnContexts: [...existingSession.turnContexts] } : {}),
+                ...(existingSession.rolloutJournal ? { rolloutJournal: [...existingSession.rolloutJournal] } : {}),
                 ...(existingSession.usage ? { usage: cloneUsage(existingSession.usage) } : {}),
             };
         }
@@ -114,24 +191,53 @@ export class ChatHistory {
     }
     /** Append a user message and persist to disk BEFORE adapter execution. */
     async appendUserMessage(content, options = {}) {
+        const turnIndex = this.session.messages.length;
         this.session.messages.push({
             role: "user",
             content,
             timestamp: new Date().toISOString(),
-            turnIndex: this.session.messages.length,
+            turnIndex,
             ...(options.setupSecretIntake && options.setupSecretIntake.length > 0
                 ? { setupSecretIntake: options.setupSecretIntake }
                 : {}),
         });
+        this.pushRolloutRecord({
+            kind: "user_input",
+            source: "chat_history",
+            visibility: "model_visible",
+            eventContext: options.eventContext,
+            payload: {
+                role: "user",
+                content,
+                turnIndex,
+                ...(options.userInput ? { userInput: toReplayableUserInput(options.userInput) } : {}),
+                ...(options.setupSecretIntake && options.setupSecretIntake.length > 0
+                    ? { setupSecretIntake: options.setupSecretIntake }
+                    : {}),
+            },
+        });
         await this.persist();
     }
     /** Append an assistant message and persist it as the committed assistant turn. */
-    async appendAssistantMessage(content) {
+    async appendAssistantMessage(content, options = {}) {
+        const safeContent = redactSetupSecrets(content);
+        const turnIndex = this.session.messages.length;
         this.session.messages.push({
             role: "assistant",
-            content: redactSetupSecrets(content),
+            content: safeContent,
             timestamp: new Date().toISOString(),
-            turnIndex: this.session.messages.length,
+            turnIndex,
+        });
+        this.pushRolloutRecord({
+            kind: "model_output",
+            source: "chat_history",
+            visibility: "model_visible",
+            eventContext: options.eventContext,
+            payload: {
+                role: "assistant",
+                content: safeContent,
+                turnIndex,
+            },
         });
         await this.persist();
     }
@@ -139,18 +245,28 @@ export class ChatHistory {
     async clear() {
         this.session.messages = [];
         delete this.session.compactionSummary;
+        delete this.session.compactionRecords;
+        this.replaceModelVisibleJournalFromMessages("clear");
         await this.persist();
     }
     /** Persist a compacted summary and keep only the latest turns in message history. */
     async compact(summary, keepMessageCount = 4) {
         const before = this.session.messages.length;
         const keepCount = Math.max(0, keepMessageCount);
+        const originalMessages = [...this.session.messages];
         const kept = keepCount === 0 ? [] : this.session.messages.slice(-keepCount);
+        const removed = keepCount === 0 ? originalMessages : originalMessages.slice(0, -keepCount);
+        const record = this.buildCompactionRecord(summary, originalMessages, removed, kept);
         this.session.messages = kept.map((message, index) => ({
             ...message,
             turnIndex: index,
         }));
         this.session.compactionSummary = summary;
+        this.session.compactionRecords = [
+            ...(this.session.compactionRecords ?? []),
+            record,
+        ].slice(-50);
+        this.replaceModelVisibleJournalFromMessages("compact");
         await this.persist();
         return { before, after: this.session.messages.length };
     }
@@ -170,16 +286,23 @@ export class ChatHistory {
             ...message,
             turnIndex: index,
         }));
+        this.replaceModelVisibleJournalFromMessages("remove_last_turn");
         await this.persist();
         return removed;
     }
     getMessages() {
         return [...this.session.messages];
     }
+    getModelVisibleMessages() {
+        return reconstructModelVisibleMessagesFromRolloutJournal(this.session.rolloutJournal) ?? this.getMessages();
+    }
     getSessionData() {
         return {
             ...this.session,
             messages: [...this.session.messages],
+            ...(this.session.compactionRecords ? { compactionRecords: cloneCompactionRecords(this.session.compactionRecords) } : {}),
+            ...(this.session.turnContexts ? { turnContexts: [...this.session.turnContexts] } : {}),
+            ...(this.session.rolloutJournal ? { rolloutJournal: [...this.session.rolloutJournal] } : {}),
             ...(this.session.usage ? { usage: cloneUsage(this.session.usage) } : {}),
         };
     }
@@ -232,6 +355,34 @@ export class ChatHistory {
             delete this.session.runSpecConfirmation;
         }
     }
+    async recordTurnContext(snapshot) {
+        this.session.turnContexts = [
+            ...(this.session.turnContexts ?? []),
+            snapshot,
+        ].slice(-20);
+        this.pushRolloutRecord({
+            kind: "turn_context",
+            source: "chat_history",
+            visibility: "model_visible",
+            eventContext: extractTurnContextEventContext(snapshot),
+            payload: snapshot,
+        });
+        await this.persist();
+    }
+    async recordChatEvent(event, options = {}) {
+        const projection = rolloutProjectionFromChatEvent(event);
+        this.pushRolloutRecord({
+            kind: projection.kind,
+            source: projection.source,
+            visibility: projection.visibility,
+            eventContext: event,
+            createdAt: event.createdAt,
+            payload: projection.payload,
+        });
+        if (options.persist !== false) {
+            await this.persist();
+        }
+    }
     setSessionLifecycle(input) {
         if (input.status !== undefined) {
             if (input.status)
@@ -355,6 +506,374 @@ export class ChatHistory {
         this.session.updatedAt = new Date().toISOString();
         await this.stateManager.writeRaw(`chat/sessions/${this.sessionId}.json`, this.session);
     }
+    pushRolloutRecord(input) {
+        const current = this.session.rolloutJournal ?? [];
+        const sequence = nextRolloutSequence(current);
+        const runId = typeof input.eventContext?.runId === "string" ? input.eventContext.runId : null;
+        const turnId = typeof input.eventContext?.turnId === "string" ? input.eventContext.turnId : null;
+        const record = ChatRolloutJournalRecordSchema.parse({
+            schema_version: "chat-rollout-journal-record-v1",
+            id: `${this.sessionId}:${sequence}`,
+            sessionId: this.sessionId,
+            runId,
+            turnId,
+            sequence,
+            createdAt: input.createdAt ?? new Date().toISOString(),
+            kind: input.kind,
+            source: input.source,
+            visibility: input.visibility,
+            payload: redactSetupSecretsDeep(input.payload),
+        });
+        this.session.rolloutJournal = [...current, record].slice(-500);
+    }
+    replaceModelVisibleJournalFromMessages(reason) {
+        const demoted = (this.session.rolloutJournal ?? []).map((record) => record.source === "chat_history"
+            && record.visibility === "model_visible"
+            && (record.kind === "user_input" || record.kind === "model_output")
+            ? {
+                ...record,
+                visibility: "debug",
+                payload: {
+                    ...(isRecord(record.payload) ? record.payload : {}),
+                    modelVisibleUntil: reason,
+                },
+            }
+            : record);
+        this.session.rolloutJournal = demoted;
+        for (const message of this.session.messages) {
+            this.pushRolloutRecord({
+                kind: message.role === "assistant" ? "model_output" : "user_input",
+                source: "chat_history",
+                visibility: "model_visible",
+                payload: {
+                    role: message.role,
+                    content: message.content,
+                    turnIndex: message.turnIndex,
+                    historyMutation: reason,
+                    ...(message.setupSecretIntake && message.setupSecretIntake.length > 0
+                        ? { setupSecretIntake: message.setupSecretIntake }
+                        : {}),
+                },
+            });
+        }
+    }
+    buildCompactionRecord(summary, originalMessages, removed, retained) {
+        const current = this.session.compactionRecords ?? [];
+        const sequence = nextCompactionSequence(current);
+        const rewrittenTurnIndexes = retained.map((_message, index) => index);
+        const rolloutJournal = this.session.rolloutJournal ?? [];
+        const record = ChatCompactionRecordSchema.parse({
+            schema_version: CHAT_COMPACTION_RECORD_SCHEMA_VERSION,
+            id: `${this.sessionId}:compaction:${sequence}`,
+            sessionId: this.sessionId,
+            sequence,
+            createdAt: new Date().toISOString(),
+            reason: "manual_command",
+            inputMessageCount: originalMessages.length,
+            outputMessageCount: retained.length,
+            removedMessageCount: removed.length,
+            retainedMessageCount: retained.length,
+            summary,
+            modelVisibleSummary: summary,
+            archivedUserMessages: removed.filter((message) => message.role === "user"),
+            archivedAssistantMessages: removed.filter((message) => message.role === "assistant"),
+            retainedMessages: retained,
+            pendingPermissions: collectPendingPermissionRecords(rolloutJournal),
+            decisions: collectDecisionRecords(rolloutJournal),
+            activeTargets: collectActiveTargets(this.session, retained),
+            replacementHistory: {
+                removedTurnIndexes: removed.map((message) => message.turnIndex),
+                retainedOriginalTurnIndexes: retained.map((message) => message.turnIndex),
+                rewrittenTurnIndexes,
+                rolloutJournalSequences: rolloutJournal.map((record) => record.sequence),
+                turnContextCount: this.session.turnContexts?.length ?? 0,
+            },
+        });
+        return record;
+    }
+}
+export function reconstructModelVisibleMessagesFromRolloutJournal(records) {
+    const modelRecords = (records ?? [])
+        .filter((record) => record.source === "chat_history"
+        && record.visibility === "model_visible"
+        && (record.kind === "user_input" || record.kind === "model_output"))
+        .sort((left, right) => left.sequence - right.sequence);
+    if (modelRecords.length === 0)
+        return null;
+    return modelRecords.flatMap((record, index) => {
+        const payload = isRecord(record.payload) ? record.payload : {};
+        const role = payload["role"] === "assistant" ? "assistant" : payload["role"] === "user" ? "user" : null;
+        const content = typeof payload["content"] === "string" ? payload["content"] : null;
+        if (!role || content === null)
+            return [];
+        const setupSecretIntake = Array.isArray(payload["setupSecretIntake"])
+            ? { setupSecretIntake: payload["setupSecretIntake"] }
+            : {};
+        return [{
+                role,
+                content,
+                timestamp: record.createdAt,
+                turnIndex: index,
+                ...setupSecretIntake,
+            }];
+    });
+}
+function nextRolloutSequence(records) {
+    return records.reduce((max, record) => Math.max(max, record.sequence), -1) + 1;
+}
+function nextCompactionSequence(records) {
+    return records.reduce((max, record) => Math.max(max, record.sequence), -1) + 1;
+}
+function cloneCompactionRecords(records) {
+    return records.map((record) => ChatCompactionRecordSchema.parse(cloneJson(record)));
+}
+function collectPendingPermissionRecords(records) {
+    return records.flatMap((record) => {
+        if (record.kind !== "permission_decision")
+            return [];
+        const payload = isRecord(record.payload) ? record.payload : {};
+        const status = permissionStatus(payload);
+        return [{
+                sequence: record.sequence,
+                source: record.source,
+                status,
+                invalidatedByCompaction: status === "requested",
+                payload: cloneJson(record.payload),
+            }];
+    });
+}
+function collectDecisionRecords(records) {
+    return records.flatMap((record) => {
+        if (record.kind !== "turn_context"
+            && record.kind !== "permission_decision"
+            && record.kind !== "completion_state") {
+            return [];
+        }
+        return [{
+                sequence: record.sequence,
+                kind: record.kind,
+                source: record.source,
+                visibility: record.visibility,
+                payload: cloneJson(record.payload),
+            }];
+    });
+}
+function collectActiveTargets(session, retainedMessages) {
+    const targets = [{
+            source: "retained_messages",
+            state: "retained",
+            payload: retainedMessages.map((message) => ({
+                role: message.role,
+                turnIndex: message.turnIndex,
+                timestamp: message.timestamp,
+            })),
+        }];
+    if (session.notificationReplyTarget) {
+        targets.push({
+            source: "notification_reply_target",
+            state: "session",
+            payload: cloneJson(session.notificationReplyTarget),
+        });
+    }
+    if (session.agentLoopStatePath || session.agentLoop) {
+        targets.push({
+            source: "agent_loop",
+            state: "session",
+            payload: {
+                statePath: session.agentLoopStatePath ?? session.agentLoop?.statePath ?? null,
+                status: session.agentLoopStatus ?? session.agentLoop?.status ?? null,
+                resumable: session.agentLoopResumable ?? session.agentLoop?.resumable ?? null,
+                updatedAt: session.agentLoopUpdatedAt ?? session.agentLoop?.updatedAt ?? null,
+            },
+        });
+    }
+    if (session.runSpecConfirmation?.state === "pending") {
+        targets.push({
+            source: "run_spec_confirmation",
+            state: "session",
+            payload: {
+                state: session.runSpecConfirmation.state,
+                specId: session.runSpecConfirmation.spec.id,
+                createdAt: session.runSpecConfirmation.createdAt,
+                updatedAt: session.runSpecConfirmation.updatedAt,
+            },
+        });
+    }
+    if (session.setupDialogue) {
+        targets.push({
+            source: "setup_dialogue",
+            state: "session",
+            payload: {
+                id: session.setupDialogue.id,
+                channel: session.setupDialogue.selectedChannel,
+                state: session.setupDialogue.state,
+                updatedAt: session.setupDialogue.updatedAt,
+            },
+        });
+    }
+    return targets;
+}
+function permissionStatus(payload) {
+    if (payload["state"] === "requested")
+        return "requested";
+    if (payload["state"] === "approved" || payload["state"] === "denied" || payload["state"] === "resolved") {
+        return "resolved";
+    }
+    const item = isRecord(payload["item"]) ? payload["item"] : null;
+    if (item?.["status"] === "requested" || item?.["status"] === "awaiting_approval")
+        return "requested";
+    if (item?.["status"] === "approved" || item?.["status"] === "denied")
+        return "resolved";
+    return "unknown";
+}
+function extractTurnContextEventContext(snapshot) {
+    const modelVisible = isRecord(snapshot.modelVisible) ? snapshot.modelVisible : null;
+    const turn = modelVisible && isRecord(modelVisible["turn"]) ? modelVisible["turn"] : null;
+    const runId = typeof turn?.["runId"] === "string" ? turn["runId"] : undefined;
+    const turnId = typeof turn?.["turnId"] === "string" ? turn["turnId"] : undefined;
+    return runId && turnId ? { runId, turnId } : undefined;
+}
+function toReplayableUserInput(input) {
+    return {
+        schema_version: input.schema_version,
+        ...(input.rawText !== undefined ? { rawText: input.rawText } : {}),
+        items: input.items.map((item) => {
+            switch (item.kind) {
+                case "text":
+                    return { kind: "text", text: item.text };
+                case "image":
+                case "local_image":
+                    return {
+                        kind: item.kind,
+                        ...(item.name ? { name: item.name } : {}),
+                    };
+                case "mention":
+                    return {
+                        kind: "mention",
+                        ...(item.label ? { label: item.label } : {}),
+                    };
+                case "skill":
+                case "plugin":
+                case "tool":
+                    return { kind: item.kind, name: item.name };
+                case "attachment":
+                    return {
+                        kind: "attachment",
+                        id: item.id,
+                        ...(item.name ? { name: item.name } : {}),
+                        ...(item.mimeType ? { mimeType: item.mimeType } : {}),
+                    };
+            }
+        }),
+    };
+}
+function rolloutProjectionFromChatEvent(event) {
+    if (event.type === "tool_start") {
+        return {
+            kind: "tool_call",
+            source: "chat_event",
+            visibility: "debug",
+            payload: { event },
+        };
+    }
+    if (event.type === "tool_end") {
+        return {
+            kind: "tool_result",
+            source: "chat_event",
+            visibility: "debug",
+            payload: { event },
+        };
+    }
+    if (event.type === "tool_update" && event.status === "awaiting_approval") {
+        return {
+            kind: "permission_decision",
+            source: "chat_event",
+            visibility: "host_only",
+            payload: { state: "requested", event },
+        };
+    }
+    if (event.type === "agent_timeline") {
+        return rolloutProjectionFromAgentTimelineEvent(event);
+    }
+    if (event.type === "assistant_final") {
+        return {
+            kind: "model_output",
+            source: "chat_event",
+            visibility: "model_visible",
+            payload: {
+                role: "assistant",
+                content: event.text,
+                persisted: event.persisted,
+                event,
+            },
+        };
+    }
+    if (event.type === "lifecycle_end" || event.type === "lifecycle_error") {
+        return {
+            kind: "completion_state",
+            source: "chat_event",
+            visibility: "debug",
+            payload: { event },
+        };
+    }
+    return {
+        kind: "display_event",
+        source: "chat_event",
+        visibility: "display",
+        payload: { event },
+    };
+}
+function rolloutProjectionFromAgentTimelineEvent(event) {
+    const item = event.item;
+    if (item.kind === "model_request" || item.kind === "assistant_message") {
+        return {
+            kind: "model_output",
+            source: "agent_timeline",
+            visibility: item.visibility === "debug" ? "debug" : "model_visible",
+            payload: { item },
+        };
+    }
+    if (item.kind === "tool" && item.status === "started") {
+        return {
+            kind: "tool_call",
+            source: "agent_timeline",
+            visibility: "debug",
+            payload: { item },
+        };
+    }
+    if (item.kind === "tool" || item.kind === "tool_observation") {
+        return {
+            kind: "tool_result",
+            source: "agent_timeline",
+            visibility: item.visibility === "debug" ? "debug" : "display",
+            payload: { item },
+        };
+    }
+    if (item.kind === "approval") {
+        return {
+            kind: "permission_decision",
+            source: "agent_timeline",
+            visibility: "host_only",
+            payload: { item },
+        };
+    }
+    if (item.kind === "final" || item.kind === "stopped") {
+        return {
+            kind: "completion_state",
+            source: "agent_timeline",
+            visibility: "debug",
+            payload: { item },
+        };
+    }
+    return {
+        kind: "display_event",
+        source: "agent_timeline",
+        visibility: item.visibility === "debug" ? "debug" : "display",
+        payload: { item },
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeUsageCounter(usage) {
     const inputTokens = Number.isFinite(usage.inputTokens) ? Math.max(0, Math.floor(usage.inputTokens)) : 0;
@@ -383,4 +902,9 @@ function cloneUsage(usage) {
         ...(usage.updatedAt ? { updatedAt: usage.updatedAt } : {}),
     };
 }
+function cloneJson(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
 //# sourceMappingURL=chat-history.js.map