@aexol/spectral 0.9.220 → 0.9.222

package/dist/server/session-stream/history-prune.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Persisted-history pruning after compaction: derive the kept branch
+ * message signatures, match them against SQLite history, and delete the
+ * pruned remainder after a successful compaction_end. Bodies moved
+ * verbatim from `session-stream.ts`.
+ */
+import type { BridgeLike } from "../session-stream.js";
+import type { SessionStore } from "../storage.js";
+import type { ServerEvent, WireMessage } from "../wire.js";
+export type CompactionEndPruneSkipReason = "aborted" | "skipped" | "failed" | "missing_token_reduction";
+export declare function getCompactionEndPruneSkipReason(event: Extract<ServerEvent, {
+    type: "compaction_end";
+}>): CompactionEndPruneSkipReason | null;
+export type BranchEntryLike = NonNullable<ReturnType<NonNullable<BridgeLike["getSessionBranch"]>>>[number];
+export type PersistedConversationRole = "user" | "assistant";
+export interface KeptBranchMessageSignature {
+    role: PersistedConversationRole;
+    content: string;
+    timestampMs: number | null;
+    entryId: string;
+}
+export interface ExistingConversationMessage {
+    message: WireMessage;
+    conversationIndex: number;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function contentAsPersistedText(content: unknown): string | null;
+export declare function branchMessageTimestampMs(entry: BranchEntryLike, message: Record<string, unknown>): number | null;
+export declare function branchMessageSignature(entry: BranchEntryLike): KeptBranchMessageSignature | null;
+export declare function branchMessageRole(entry: BranchEntryLike): unknown;
+export declare function getKeptBranchMessageSignatures(entries: BranchEntryLike[], keptEntryIndex: number): KeptBranchMessageSignature[] | null;
+export declare function selectUniqueCandidate(candidates: ExistingConversationMessage[], kept: KeptBranchMessageSignature): ExistingConversationMessage | null;
+export declare function matchKeptPersistedMessageIds(existing: WireMessage[], keptBranchMessages: KeptBranchMessageSignature[]): Set<string> | null;
+export declare function prunePersistedHistoryAfterCompaction(store: SessionStore, sessionId: string, bridge: BridgeLike): void;
+//# sourceMappingURL=history-prune.d.ts.map

package/dist/server/session-stream/history-prune.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-prune.d.ts","sourceRoot":"","sources":["../../../src/server/session-stream/history-prune.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE3D,MAAM,MAAM,4BAA4B,GACtC,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,yBAAyB,CAAC;AAM/D,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,GACtD,4BAA4B,GAAG,IAAI,CAOrC;AAED,MAAM,MAAM,eAAe,GAAG,WAAW,CACvC,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CACxD,CAAC,MAAM,CAAC,CAAC;AACV,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,WAAW,CAAC;AAE7D,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,WAAW,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAID,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmBtE;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,eAAe,EACtB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,MAAM,GAAG,IAAI,CASf;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,eAAe,GACrB,0BAA0B,GAAG,IAAI,CAYnC;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAIjE;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,EAAE,EAC1B,cAAc,EAAE,MAAM,GACrB,0BAA0B,EAAE,GAAG,IAAI,CAkBrC;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,2BAA2B,EAAE,EACzC,IAAI,EAAE,0BAA0B,GAC/B,2BAA2B,GAAG,IAAI,CAUpC;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,WAAW,EAAE,EACvB,kBAAkB,EAAE,0BAA0B,EAAE,GAC/C,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CA+BpB;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,IAAI,CA4FN"}

package/dist/server/session-stream/history-prune.js

@@ -0,0 +1,182 @@
+// Persisted-history prune is deliberately stricter than timeline status
+// rendering: only a successful compaction_end proves Pi appended a usable
+// compaction entry. Aborted, skipped, or failed endings may leave the branch
+// unchanged or partially settled, so pruning must skip instead of guessing.
+export function getCompactionEndPruneSkipReason(event) {
+    if (event.aborted)
+        return "aborted";
+    if (event.skipped)
+        return "skipped";
+    if (event.errorMessage)
+        return "failed";
+    if (typeof event.tokensRemoved !== "number" || event.tokensRemoved <= 0)
+        return "missing_token_reduction";
+    return null;
+}
+const BRANCH_MESSAGE_TIMESTAMP_TOLERANCE_MS = 5_000;
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function contentAsPersistedText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const textParts = [];
+    for (const part of content) {
+        if (typeof part === "string") {
+            textParts.push(part);
+            continue;
+        }
+        if (isRecord(part) &&
+            part.type === "text" &&
+            typeof part.text === "string") {
+            textParts.push(part.text);
+        }
+    }
+    return textParts.length > 0 ? textParts.join("") : null;
+}
+export function branchMessageTimestampMs(entry, message) {
+    if (typeof message.timestamp === "number" &&
+        Number.isFinite(message.timestamp))
+        return message.timestamp;
+    if (typeof entry.timestamp !== "string")
+        return null;
+    const parsed = Date.parse(entry.timestamp);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function branchMessageSignature(entry) {
+    if (entry.type !== "message" || !isRecord(entry.message))
+        return null;
+    const role = entry.message.role;
+    if (role !== "user" && role !== "assistant")
+        return null;
+    const content = contentAsPersistedText(entry.message.content);
+    if (content === null)
+        return null;
+    return {
+        role,
+        content,
+        timestampMs: branchMessageTimestampMs(entry, entry.message),
+        entryId: entry.id,
+    };
+}
+export function branchMessageRole(entry) {
+    return entry.type === "message" && isRecord(entry.message)
+        ? entry.message.role
+        : undefined;
+}
+export function getKeptBranchMessageSignatures(entries, keptEntryIndex) {
+    const signatures = [];
+    for (let i = keptEntryIndex; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry.type !== "message")
+            continue;
+        const role = branchMessageRole(entry);
+        if (role !== "user" && role !== "assistant")
+            continue;
+        const signature = branchMessageSignature(entry);
+        if (!signature) {
+            console.log(`[spectral] prune: skipped – reason=unsafe_kept_message, ` +
+                `kept branch message ${entry.id} cannot be matched safely`);
+            return null;
+        }
+        signatures.push(signature);
+    }
+    return signatures;
+}
+export function selectUniqueCandidate(candidates, kept) {
+    if (candidates.length === 1)
+        return candidates[0];
+    if (kept.timestampMs === null)
+        return null;
+    const keptTimestampMs = kept.timestampMs;
+    const timestampMatches = candidates.filter((candidate) => Math.abs(candidate.message.createdAt - keptTimestampMs) <=
+        BRANCH_MESSAGE_TIMESTAMP_TOLERANCE_MS);
+    return timestampMatches.length === 1 ? timestampMatches[0] : null;
+}
+export function matchKeptPersistedMessageIds(existing, keptBranchMessages) {
+    const existingConversationMessages = existing
+        .filter((message) => message.role === "user" || message.role === "assistant")
+        .map((message, conversationIndex) => ({ message, conversationIndex }));
+    const matchedIds = new Set();
+    let searchStart = 0;
+    for (const kept of keptBranchMessages) {
+        const candidates = existingConversationMessages.filter((candidate) => candidate.conversationIndex >= searchStart &&
+            !matchedIds.has(candidate.message.id) &&
+            candidate.message.role === kept.role &&
+            candidate.message.content === kept.content);
+        const selected = selectUniqueCandidate(candidates, kept);
+        if (!selected) {
+            console.log(`[spectral] prune: skipped – reason=ambiguous_kept_mapping, ` +
+                `could not stably match kept branch entry ${kept.entryId} ` +
+                `(${kept.role}, ${kept.content.length.toLocaleString()} chars) to SQLite history`);
+            return null;
+        }
+        matchedIds.add(selected.message.id);
+        searchStart = selected.conversationIndex + 1;
+    }
+    return matchedIds;
+}
+export function prunePersistedHistoryAfterCompaction(store, sessionId, bridge) {
+    if (!bridge.getSessionBranch)
+        return;
+    try {
+        const entries = bridge.getSessionBranch();
+        // Pi appends a CompactionEntry (type "compaction") at the end whose
+        // firstKeptEntryId marks the first branch entry that survives in LLM context.
+        // We scan backwards so we find the most recent compaction (there should be
+        // exactly one per compaction pass).
+        const lastCompaction = [...entries]
+            .reverse()
+            .find((entry) => entry.type === "compaction");
+        const firstKeptEntryId = lastCompaction?.firstKeptEntryId;
+        if (!firstKeptEntryId) {
+            console.log(`[spectral] prune: skipped – reason=missing_compaction_entry, ` +
+                `no compaction entry (or no firstKeptEntryId) ` +
+                `in branch for ${sessionId} (${entries.length} entries)`);
+            return;
+        }
+        const keptEntryIndex = entries.findIndex((entry) => entry.id === firstKeptEntryId);
+        if (keptEntryIndex === -1) {
+            console.log(`[spectral] prune: skipped – reason=missing_kept_entry, ` +
+                `firstKeptEntryId "${firstKeptEntryId}" ` +
+                `not found in ${entries.length} branch entries for ${sessionId}`);
+            return;
+        }
+        const keptBranchMessages = getKeptBranchMessageSignatures(entries, keptEntryIndex);
+        if (!keptBranchMessages)
+            return;
+        const existing = store.getMessages(sessionId);
+        if (existing.length === 0)
+            return;
+        if (keptBranchMessages.length === 0) {
+            console.log(`[spectral] prune: skipped – reason=no_kept_conversation_messages, ` +
+                `no kept persisted user/assistant messages for ${sessionId}`);
+            return;
+        }
+        console.log(`[spectral] prune: ${sessionId} – source=compaction_end, branch has ${entries.length} entries, ` +
+            `kept portion starts at index ${keptEntryIndex} (id=${firstKeptEntryId}), ` +
+            `${keptBranchMessages.length} user+assistant entries kept, ` +
+            `${existing.length} SQLite messages`);
+        const matchedKeptIds = matchKeptPersistedMessageIds(existing, keptBranchMessages);
+        if (!matchedKeptIds)
+            return;
+        const deleteIds = existing
+            .filter((message) => (message.role === "user" || message.role === "assistant") &&
+            !matchedKeptIds.has(message.id))
+            .map((message) => message.id);
+        if (deleteIds.length === 0) {
+            console.log(`[spectral] prune: skipped – reason=already_pruned, ` +
+                `SQLite history already matches compacted branch for ${sessionId}`);
+            return;
+        }
+        const pruned = store.deleteMessagesByIdForSession(sessionId, deleteIds);
+        console.log(`[spectral] prune: finished – reason=successful_compaction_end, ` +
+            `dropped ${pruned} pre-compaction message(s) ` +
+            `for ${sessionId}, ${matchedKeptIds.size} user/assistant message(s) kept`);
+    }
+    catch (err) {
+        console.warn(`[spectral] warn: failed to prune persisted history after compaction for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/server/session-stream/memory.d.ts

@@ -0,0 +1,48 @@
+import { type CompactionPolicy } from "../../sdk/coding-agent/core/compaction/policy.js";
+import { type Config } from "../../memory/config.js";
+import type { BridgeLike, SessionStream } from "../session-stream.js";
+import type { SessionStore } from "../storage.js";
+import type { ServerEvent, WireDcpLiteStatus } from "../wire.js";
+export declare function persistObservationalMemorySnapshot(store: SessionStore, sessionId: string, bridge: BridgeLike): void;
+export declare function loadCompactionPolicy(cwd: string): CompactionPolicy;
+export type SessionDcpLiteThresholds = WireDcpLiteStatus["thresholds"];
+export interface SessionDcpLiteStatus extends Omit<WireDcpLiteStatus, "thresholds"> {
+    thresholds: SessionDcpLiteThresholds;
+}
+export interface SessionMemoryStatus {
+    mode: "active" | "passive";
+    phase: "idle" | "observing" | "compacting" | "reflecting" | "pruning";
+    inFlight: {
+        observer: boolean;
+        compaction: boolean;
+        reflection: boolean;
+        pruner: boolean;
+    };
+    reflections: {
+        count: number;
+        tokens: number;
+    };
+    observations: {
+        committedCount: number;
+        committedTokens: number;
+        pendingCount: number;
+        pendingTokens: number;
+    };
+    thresholds: {
+        observation: number;
+        compaction: number;
+        reflection: number;
+    };
+    progress: {
+        sinceObservationBoundTokens: number;
+        sinceLastCompactionTokens: number;
+        observationPoolTokens: number;
+    };
+    dcpLite?: SessionDcpLiteStatus;
+}
+export declare function buildDcpLiteThresholds(config: Config, policy: CompactionPolicy): SessionDcpLiteThresholds;
+export declare function contextPercent(usedTokens: number | null, maxTokens: number | null): number | null;
+export declare function applyDcpLiteRuntimeStatus(status: SessionMemoryStatus, stream: SessionStream | undefined): void;
+export declare function dcpLiteEventFromServerEvent(event: ServerEvent): WireDcpLiteStatus["lastEvent"] | null;
+export declare function defaultMemoryStatus(cwd: string): SessionMemoryStatus;
+//# sourceMappingURL=memory.d.ts.map

package/dist/server/session-stream/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/server/session-stream/memory.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,kDAAkD,CAAC;AAG1D,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEjE,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,YAAY,EACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,UAAU,GACjB,IAAI,CAmCN;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAMlE;AAED,MAAM,MAAM,wBAAwB,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;AAEvE,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC;IACjF,UAAU,EAAE,wBAAwB,CAAC;CACtC;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC3B,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;IACtE,QAAQ,EAAE;QACR,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,UAAU,EAAE,OAAO,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,YAAY,EAAE;QACZ,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,UAAU,EAAE;QACV,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,QAAQ,EAAE;QACR,2BAA2B,EAAE,MAAM,CAAC;QACpC,yBAAyB,EAAE,MAAM,CAAC;QAClC,qBAAqB,EAAE,MAAM,CAAC;KAC/B,CAAC;IACF,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,gBAAgB,GACvB,wBAAwB,CAa1B;AAED,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,EACzB,SAAS,EAAE,MAAM,GAAG,IAAI,GACvB,MAAM,GAAG,IAAI,CAQf;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,aAAa,GAAG,SAAS,GAChC,IAAI,CAYN;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,WAAW,GACjB,iBAAiB,CAAC,WAAW,CAAC,GAAG,IAAI,CAoBvC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAiCpE"}

package/dist/server/session-stream/memory.js

@@ -0,0 +1,136 @@
+/**
+ * Observational-memory session status / DCP-lite status computation and
+ * snapshot persistence helpers. Bodies moved verbatim from
+ * `session-stream.ts`.
+ */
+import { SettingsManager } from "../../sdk/coding-agent/index.js";
+import { CONTEXT_LIMIT_RATIO, DEFAULT_COMPACTION_POLICY, } from "../../sdk/coding-agent/core/compaction/policy.js";
+import { getMemoryState, isSourceEntry } from "../../memory/branch.js";
+import { renderSummary } from "../../memory/compaction.js";
+import { loadConfig } from "../../memory/config.js";
+export function persistObservationalMemorySnapshot(store, sessionId, bridge) {
+    if (!bridge.getSessionBranch)
+        return;
+    try {
+        const entries = bridge.getSessionBranch();
+        const memoryState = getMemoryState(entries);
+        const allObservations = [
+            ...memoryState.committedObs,
+            ...memoryState.pendingObs,
+        ];
+        const hasMemory = memoryState.reflections.length > 0 || allObservations.length > 0;
+        if (!hasMemory) {
+            store.deleteSessionMemorySnapshot(sessionId);
+            return;
+        }
+        const summary = renderSummary(memoryState.reflections, allObservations);
+        const details = {
+            type: "observational-memory",
+            version: 4,
+            observations: allObservations,
+            reflections: memoryState.reflections,
+        };
+        store.upsertSessionMemorySnapshot(sessionId, {
+            summary,
+            details,
+            coveredSourceCount: entries.filter((entry) => isSourceEntry(entry))
+                .length,
+        });
+    }
+    catch (err) {
+        console.warn(`[spectral] warn: failed to persist observational memory snapshot for ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export function loadCompactionPolicy(cwd) {
+    try {
+        return SettingsManager.create(cwd).getCompactionPolicy();
+    }
+    catch {
+        return DEFAULT_COMPACTION_POLICY;
+    }
+}
+export function buildDcpLiteThresholds(config, policy) {
+    return {
+        postRunCompactionThresholdTokens: Math.max(config.compactionThresholdTokens, policy.autoOlderHistory.minRawTokens),
+        autoContextLimitRatio: CONTEXT_LIMIT_RATIO,
+        olderHistoryKeepRecentTokens: policy.agentDriven.olderHistoryKeepRecentTokens,
+        olderHistoryMinCompactableTokens: policy.agentDriven.olderHistoryMinCompactableTokens,
+        cooldownTurns: policy.agentDriven.cooldownTurns,
+    };
+}
+export function contextPercent(usedTokens, maxTokens) {
+    if (typeof usedTokens !== "number" ||
+        typeof maxTokens !== "number" ||
+        maxTokens <= 0)
+        return null;
+    return Math.max(0, Math.min(100, (usedTokens / maxTokens) * 100));
+}
+export function applyDcpLiteRuntimeStatus(status, stream) {
+    if (!status.dcpLite || !stream)
+        return;
+    const usage = stream.bridge.getContextUsage?.();
+    const usedTokens = usage ? usage.tokens : stream.contextWindowUsed;
+    const maxTokens = usage ? usage.contextWindow : stream.contextWindowMax;
+    const percent = usage?.percent ?? contextPercent(usedTokens, maxTokens);
+    if (usage || usedTokens !== null || maxTokens !== null) {
+        status.dcpLite.contextWindow = { usedTokens, maxTokens, percent };
+    }
+    if (stream.lastDcpEvent) {
+        status.dcpLite.lastEvent = stream.lastDcpEvent;
+    }
+}
+export function dcpLiteEventFromServerEvent(event) {
+    if (event.type !== "agent_notification" || !event.dcpLiteTelemetry)
+        return null;
+    const telemetry = event.dcpLiteTelemetry;
+    return {
+        kind: telemetry.event,
+        message: event.message,
+        timestamp: telemetry.timestamp,
+        source: telemetry.source,
+        mode: telemetry.mode,
+        scope: telemetry.scope,
+        reason: telemetry.reason,
+        satisfiedSignals: telemetry.satisfiedSignals,
+        rawTokens: telemetry.rawTokens,
+        contextTokens: telemetry.contextTokens,
+        contextPercent: telemetry.contextPercent,
+        tokensBefore: telemetry.tokensBefore,
+        tokensAfter: telemetry.tokensAfter,
+        tokensRemoved: telemetry.tokensRemoved,
+    };
+}
+export function defaultMemoryStatus(cwd) {
+    const config = loadConfig(cwd);
+    const policy = loadCompactionPolicy(cwd);
+    return {
+        mode: config.passive ? "passive" : "active",
+        phase: "idle",
+        inFlight: {
+            observer: false,
+            compaction: false,
+            reflection: false,
+            pruner: false,
+        },
+        reflections: { count: 0, tokens: 0 },
+        observations: {
+            committedCount: 0,
+            committedTokens: 0,
+            pendingCount: 0,
+            pendingTokens: 0,
+        },
+        thresholds: {
+            observation: config.observationThresholdTokens,
+            compaction: config.compactionThresholdTokens,
+            reflection: config.reflectionThresholdTokens,
+        },
+        progress: {
+            sinceObservationBoundTokens: 0,
+            sinceLastCompactionTokens: 0,
+            observationPoolTokens: 0,
+        },
+        dcpLite: {
+            thresholds: buildDcpLiteThresholds(config, policy),
+        },
+    };
+}

package/dist/server/session-stream/replay-tail.d.ts

@@ -0,0 +1,4 @@
+import type { WireMessage } from "../wire.js";
+export declare function estimateStoredMessageReplayTokens(message: WireMessage): number;
+export declare function selectHistoryForBridge(history: WireMessage[] | undefined, hasMemorySnapshot: boolean): WireMessage[] | undefined;
+//# sourceMappingURL=replay-tail.d.ts.map

package/dist/server/session-stream/replay-tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-tail.d.ts","sourceRoot":"","sources":["../../../src/server/session-stream/replay-tail.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAe9C,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAM9E;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,WAAW,EAAE,GAAG,SAAS,EAClC,iBAAiB,EAAE,OAAO,GACzB,WAAW,EAAE,GAAG,SAAS,CAc3B"}

package/dist/server/session-stream/replay-tail.js

@@ -0,0 +1,39 @@
+/**
+ * Fresh-bridge history replay tail selection used on attach/rehydrate.
+ * Bodies moved verbatim from `session-stream.ts`.
+ */
+import { estimateStringTokens } from "../../memory/tokens.js";
+import { estimateImagesTokens } from "../image-attachments.js";
+/**
+ * Defensive cap for fresh-bridge history replay when we already have a
+ * persisted observational-memory snapshot. spectral's own compaction keeps a
+ * recent live tail verbatim and summarizes the older prefix; replaying the
+ * entire SQLite transcript after restart defeats that and can explode the
+ * next prompt. We therefore rehydrate only an approximate recent tail.
+ *
+ * Keep this conservative — the tail is rehydrated as raw user/assistant
+ * messages PLUS spectral reconstructs tool-result messages from events_jsonl,
+ * so the actual context inflation is 3-8× the stored token estimate.
+ */
+const REHYDRATION_TAIL_TOKEN_BUDGET = 20_000;
+export function estimateStoredMessageReplayTokens(message) {
+    return (estimateStringTokens(message.content) +
+        estimateStringTokens(message.events) +
+        estimateImagesTokens(message.images));
+}
+export function selectHistoryForBridge(history, hasMemorySnapshot) {
+    if (!history || history.length === 0)
+        return history;
+    if (!hasMemorySnapshot)
+        return history;
+    let total = 0;
+    let start = history.length - 1;
+    for (; start >= 0; start--) {
+        const nextTotal = total + estimateStoredMessageReplayTokens(history[start]);
+        if (total > 0 && nextTotal > REHYDRATION_TAIL_TOKEN_BUDGET)
+            break;
+        total = nextTotal;
+    }
+    const selected = history.slice(Math.max(0, start + 1));
+    return selected.length > 0 ? selected : [history[history.length - 1]];
+}

package/dist/server/session-stream/turn-events.d.ts

@@ -0,0 +1,33 @@
+/**
+ * In-flight turn buffering primitives: the turn event model
+ * (`BufferedTurnEvent`, `InProgressTurn`), replayability gating, turn
+ * snapshots for reconnect replay, and persist-time credit extraction from
+ * the events JSONL. Bodies moved verbatim from `session-stream.ts`.
+ */
+import type { InProgressTurnSnapshot, ReplayableTurnEvent, ServerEvent } from "../wire.js";
+/**
+ * Extract the `creditsUsed` value from a `token_usage` event embedded in an
+ * events JSONL string. Returns `null` if no `token_usage` event is present
+ * (e.g. it hasn't arrived yet at persist time — the race condition this
+ * column exists to bridge). Best-effort: malformed lines are skipped.
+ */
+export declare function extractCreditsFromEventsJsonl(eventsJsonl: string): number | null;
+export type BufferedTurnEvent = Exclude<ReplayableTurnEvent, {
+    type: "subagent_progress";
+}>;
+export interface InProgressTurn {
+    turnId: string;
+    startedAt: number;
+    events: BufferedTurnEvent[];
+    /** Text accumulated from `text_delta` events in this turn. Used by the
+     *  auto-titler so we don't have to re-read the persisted message. */
+    assistantText: string;
+    /** Number of leading events already persisted to SQLite. snapshotTurn uses this
+     * to avoid sending already-stored events again on reconnect/refresh. */
+    persistedEventCount: number;
+    cleanupStarted: boolean;
+}
+export declare function isReplayable(event: ServerEvent): event is BufferedTurnEvent;
+export declare function assistantMessageIdsForTurn(turn: InProgressTurn): Set<string>;
+export declare function snapshotTurn(turn: InProgressTurn, includePersistedEvents?: boolean): InProgressTurnSnapshot;
+//# sourceMappingURL=turn-events.d.ts.map

package/dist/server/session-stream/turn-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-events.d.ts","sourceRoot":"","sources":["../../../src/server/session-stream/turn-events.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACV,sBAAsB,EACtB,mBAAmB,EACnB,WAAW,EACZ,MAAM,YAAY,CAAC;AAEpB;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkBhF;AAED,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACrC,mBAAmB,EACnB;IAAE,IAAI,EAAE,mBAAmB,CAAA;CAAE,CAC9B,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;yEACqE;IACrE,aAAa,EAAE,MAAM,CAAC;IACtB;4EACwE;IACxE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,iBAAiB,CAoB3E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,CAAC,CAM5E;AACD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,EACpB,sBAAsB,UAAQ,GAC7B,sBAAsB,CAWxB"}

package/dist/server/session-stream/turn-events.js

@@ -0,0 +1,65 @@
+/**
+ * Extract the `creditsUsed` value from a `token_usage` event embedded in an
+ * events JSONL string. Returns `null` if no `token_usage` event is present
+ * (e.g. it hasn't arrived yet at persist time — the race condition this
+ * column exists to bridge). Best-effort: malformed lines are skipped.
+ */
+export function extractCreditsFromEventsJsonl(eventsJsonl) {
+    if (!eventsJsonl)
+        return null;
+    let creditsUsed = null;
+    for (const line of eventsJsonl.split("\n")) {
+        if (!line.includes("token_usage"))
+            continue;
+        try {
+            const ev = JSON.parse(line);
+            if (ev.type === "token_usage" &&
+                typeof ev.usage.creditsUsed === "number") {
+                creditsUsed = ev.usage.creditsUsed;
+            }
+        }
+        catch {
+            // Skip malformed lines — best-effort extraction.
+        }
+    }
+    return creditsUsed;
+}
+export function isReplayable(event) {
+    return (event.type === "message_start" ||
+        event.type === "text_delta" ||
+        event.type === "thinking_start" ||
+        event.type === "thinking_delta" ||
+        event.type === "thinking_end" ||
+        event.type === "tool_call" ||
+        event.type === "tool_result" ||
+        event.type === "message_end" ||
+        event.type === "token_usage" ||
+        event.type === "error" ||
+        event.type === "subagent_start" ||
+        // `subagent_progress` carries full accumulated live snapshots (streaming
+        // text/thinking/status) and is intentionally live-only; buffering it into
+        // currentTurn or batch persistence recreates O(n²) snapshot growth while a
+        // long subagent is running. Keep lifecycle/tool/end events replayable.
+        event.type === "subagent_end" ||
+        event.type === "subagent_tool_progress");
+}
+export function assistantMessageIdsForTurn(turn) {
+    const ids = new Set();
+    for (const event of turn.events) {
+        if (event.type === "message_start")
+            ids.add(event.messageId);
+    }
+    return ids;
+}
+export function snapshotTurn(turn, includePersistedEvents = false) {
+    // Defensive copy of the events array so the snapshot can't be mutated by
+    // subsequent buffer pushes. Individual event objects are safe to share —
+    // they're never mutated after creation.
+    return {
+        turnId: turn.turnId,
+        startedAt: turn.startedAt,
+        events: includePersistedEvents
+            ? [...turn.events]
+            : turn.events.slice(turn.persistedEventCount),
+    };
+}

package/dist/server/session-stream/turn-silence.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Turn-silence safety-net tuning (Fix E): environment-resolved silence
+ * timeout and re-arm budget for the stale-`currentTurn` watchdog. Bodies
+ * moved verbatim from `session-stream.ts`.
+ */
+export declare function resolveTurnSilenceTimeoutMs(): number;
+export declare function resolveTurnSilenceMaxRearm(): number;
+//# sourceMappingURL=turn-silence.d.ts.map

package/dist/server/session-stream/turn-silence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-silence.d.ts","sourceRoot":"","sources":["../../../src/server/session-stream/turn-silence.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAoCH,wBAAgB,2BAA2B,IAAI,MAAM,CAcpD;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAgBnD"}

package/dist/server/session-stream/turn-silence.js

@@ -0,0 +1,72 @@
+/**
+ * Turn-silence safety-net tuning (Fix E): environment-resolved silence
+ * timeout and re-arm budget for the stale-`currentTurn` watchdog. Bodies
+ * moved verbatim from `session-stream.ts`.
+ */
+// Fix E: safety-net for stale `currentTurn`. When an agent hangs, crashes,
+// or the WS drops during sleep, `agent_end` may never arrive and
+// `stream.currentTurn` stays non-null forever. On reconnect, `session_ready`
+// then reports `currentTurn != null`, so landing shows a phantom "streaming"
+// status. This timer clears the stale turn and emits a synthetic `agent_end`
+// after 30 minutes of silence on streaming-meaningful events.
+//
+// Configurable via `SPECTRAL_TURN_SILENCE_TIMEOUT_MS`:
+//   * unset / empty / not-a-number / negative -> 30 minutes (default)
+//   * `0` -> DISABLED, the timer is never armed (official opt-out)
+//   * a positive fraction (e.g. `0.5`) is rounded UP to 1ms so it can never
+//     accidentally disable the safety net
+//   * anything larger than Node's max delay is clamped (see below)
+const DEFAULT_TURN_SILENCE_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * Node emits `TimeoutOverflowWarning` and fires immediately for delays above
+ * this value, so anything larger is clamped to it.
+ */
+const MAX_TIMEOUT_DELAY_MS = 2_147_483_647;
+/**
+ * Upper bound on how many times the silence timer may be re-armed instead of
+ * closing the turn while a subagent is still running. Guards against a
+ * counter stuck at >0 forever (e.g. a `subagent_end` that never arrives after
+ * a crash) turning the safety net off permanently.
+ * `SPECTRAL_TURN_SILENCE_MAX_REARM=0` means unlimited re-arms.
+ */
+const DEFAULT_TURN_SILENCE_MAX_REARM = 8;
+/**
+ * Sanity clamp for `SPECTRAL_TURN_SILENCE_MAX_REARM`. Even with the shortest
+ * useful timeout this is days of silence, so a typo like `1e10` cannot keep a
+ * hung turn open effectively forever.
+ */
+const MAX_TURN_SILENCE_MAX_REARM = 1000;
+export function resolveTurnSilenceTimeoutMs() {
+    const raw = process.env.SPECTRAL_TURN_SILENCE_TIMEOUT_MS;
+    if (raw === undefined || raw.trim() === "") {
+        return DEFAULT_TURN_SILENCE_TIMEOUT_MS;
+    }
+    const parsed = Number(raw);
+    // `0` is the documented way to switch the safety net off entirely.
+    if (parsed === 0)
+        return 0;
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return DEFAULT_TURN_SILENCE_TIMEOUT_MS;
+    }
+    // `Math.max(1, ...)`: a fractional value such as `0.5` must floor to 1ms,
+    // not to 0 — flooring to 0 would silently switch the safety net off.
+    return Math.min(Math.max(1, Math.floor(parsed)), MAX_TIMEOUT_DELAY_MS);
+}
+export function resolveTurnSilenceMaxRearm() {
+    const raw = process.env.SPECTRAL_TURN_SILENCE_MAX_REARM;
+    // Empty / whitespace-only must NOT fall through to `Number(...)`, which
+    // coerces `""` to `0` and would therefore mean "unlimited re-arms" —
+    // i.e. the original "phantom streaming forever" bug.
+    if (raw === undefined || raw.trim() === "") {
+        return DEFAULT_TURN_SILENCE_MAX_REARM;
+    }
+    const parsed = Number(raw);
+    // `0` is the documented way to allow unlimited re-arms (opt-out of the
+    // re-arm budget).
+    if (parsed === 0)
+        return 0;
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return DEFAULT_TURN_SILENCE_MAX_REARM;
+    }
+    return Math.min(Math.max(1, Math.floor(parsed)), MAX_TURN_SILENCE_MAX_REARM);
+}