@sayknow-cli/coding-agent 0.3.6 → 0.3.8

package/src/session/agent-storage.ts

@@ -420,6 +420,10 @@ FROM model_usage_legacy
 		this.#authStore.setCache(key, value, expiresAtSec);
 	}
 
+	deleteCachePrefix(prefix: string): void {
+		this.#authStore.deleteCachePrefix?.(prefix);
+	}
+
 	/**
 	 * Deletes expired cache entries. Call periodically for cleanup.
 	 */

package/src/session/file-mention-pruning.ts

@@ -0,0 +1,64 @@
+/**
+ * Staleness pruning for auto-read file-mention entries.
+ *
+ * A `@path` mention is superseded once a newer read or mention of the same
+ * resolved path appears later in the branch. Stale bodies are replaced with an
+ * explicit digest notice (never silently deleted) so context shrinks without
+ * losing the reference.
+ */
+import type { FileMentionMessage } from "./messages";
+import type { SessionEntry, SessionMessageEntry } from "./session-manager";
+
+export interface FileMentionPruneResult {
+	changed: SessionMessageEntry[];
+	bytesSaved: number;
+}
+
+/** Notice injected in place of a superseded file-mention body. */
+export function stalefileMentionNotice(path: string): string {
+	return `(pruned: a newer view of \`${path}\` appears later in the conversation; use the read tool to fetch it again)`;
+}
+
+export function pruneStaleFileMentions(
+	entries: readonly SessionEntry[],
+	resolveAbs: (path: string) => string,
+): FileMentionPruneResult {
+	// Latest branch index at which each absolute path was shown (read or mention).
+	const latestShownIndex = new Map<string, number>();
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message") return;
+		const msg = entry.message;
+		if (msg.role === "fileMention") {
+			for (const file of msg.files) {
+				if (file.duplicate || file.pruned) continue;
+				latestShownIndex.set(resolveAbs(file.path), i);
+			}
+		} else if (msg.role === "toolResult") {
+			const resolved = (msg.details as { resolvedPath?: unknown } | undefined)?.resolvedPath;
+			if (typeof resolved === "string" && resolved) latestShownIndex.set(resolveAbs(resolved), i);
+		}
+	});
+
+	const changed: SessionMessageEntry[] = [];
+	let bytesSaved = 0;
+	entries.forEach((entry, i) => {
+		if (entry.type !== "message" || entry.message.role !== "fileMention") return;
+		const msg = entry.message as FileMentionMessage;
+		let mutated = false;
+		for (const file of msg.files) {
+			if (file.duplicate || file.pruned || !file.content) continue;
+			const latest = latestShownIndex.get(resolveAbs(file.path));
+			if (latest !== undefined && latest > i) {
+				const notice = stalefileMentionNotice(file.path);
+				bytesSaved += Math.max(0, Buffer.byteLength(file.content, "utf-8") - Buffer.byteLength(notice, "utf-8"));
+				file.content = notice;
+				file.pruned = true;
+				file.image = undefined;
+				file.lineCount = undefined;
+				mutated = true;
+			}
+		}
+		if (mutated) changed.push(entry as SessionMessageEntry);
+	});
+	return { changed, bytesSaved };
+}

package/src/session/messages.ts

@@ -192,6 +192,10 @@ export interface FileMentionMessage {
 		/** Why the file contents were omitted from auto-read. */
 		skippedReason?: "tooLarge";
 		image?: ImageContent;
+		/** Set when this mention duplicated a recently shown path (compact note, no full body). */
+		duplicate?: boolean;
+		/** Set when a stale entry was pruned to a digest notice (never silently deleted). */
+		pruned?: boolean;
 	}>;
 	timestamp: number;
 }

package/src/session/session-manager.ts

@@ -27,7 +27,9 @@ import {
 	Snowflake,
 	toError,
 } from "@sayknow-cli/utils";
+import type { TtsrInjectionRecord } from "../export/ttsr";
 import { writeTextAtomic } from "../skc-runtime/state-writer";
+
 import * as git from "../utils/git";
 import { ArtifactManager } from "./artifacts";
 import {
@@ -221,6 +223,10 @@ export interface TtsrInjectionEntry extends SessionEntryBase {
 	type: "ttsr_injection";
 	/** Names of rules that were injected */
 	injectedRules: string[];
+	/** Rich rule injection records with repeat state. */
+	injectedRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count when this injection was recorded. */
+	ttsrMessageCount?: number;
 }
 
 /** Persisted MCP discovery selection state for a session branch. */
@@ -313,6 +319,11 @@ export interface SessionContext {
 	models: Record<string, string>;
 	/** Names of TTSR rules that have been injected this session */
 	injectedTtsrRules: string[];
+	/** Rich TTSR rule injection records for repeat resume. */
+	injectedTtsrRuleRecords?: TtsrInjectionRecord[];
+	/** TTSR manager message count for repeat resume. */
+	ttsrMessageCount?: number;
+
 	/** MCP tool names selected through discovery for this session branch. */
 	selectedMCPToolNames: string[];
 	/** Whether this branch contains an explicit persisted MCP selection entry. */
@@ -612,6 +623,9 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
+
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -632,6 +646,8 @@ export function buildSessionContext(
 			serviceTier: undefined,
 			models: {},
 			injectedTtsrRules: [],
+			injectedTtsrRuleRecords: [],
+			ttsrMessageCount: 0,
 			selectedMCPToolNames: [],
 			hasPersistedMCPToolSelection: false,
 			mode: "none",
@@ -656,6 +672,9 @@ export function buildSessionContext(
 	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 	const injectedTtsrRulesSet = new Set<string>();
+	const injectedTtsrRuleRecords = new Map<string, TtsrInjectionRecord>();
+	let ttsrMessageCount = 0;
+
 	let selectedMCPToolNames: string[] = [];
 	let hasPersistedMCPToolSelection = false;
 	let mode = "none";
@@ -695,9 +714,19 @@ export function buildSessionContext(
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		} else if (entry.type === "ttsr_injection") {
-			// Collect injected TTSR rule names
+			// Collect injected TTSR rule names and richer records when present.
 			for (const ruleName of entry.injectedRules) {
 				injectedTtsrRulesSet.add(ruleName);
+				if (!injectedTtsrRuleRecords.has(ruleName)) {
+					injectedTtsrRuleRecords.set(ruleName, { name: ruleName, lastInjectedAt: 0 });
+				}
+			}
+			for (const record of entry.injectedRuleRecords ?? []) {
+				injectedTtsrRulesSet.add(record.name);
+				injectedTtsrRuleRecords.set(record.name, record);
+			}
+			if (typeof entry.ttsrMessageCount === "number" && Number.isFinite(entry.ttsrMessageCount)) {
+				ttsrMessageCount = entry.ttsrMessageCount;
 			}
 		} else if (entry.type === "mcp_tool_selection") {
 			selectedMCPToolNames = [...entry.selectedToolNames];
@@ -709,6 +738,7 @@ export function buildSessionContext(
 	}
 
 	const injectedTtsrRules = Array.from(injectedTtsrRulesSet);
+	const injectedTtsrRuleRecordsArray = Array.from(injectedTtsrRuleRecords.values());
 
 	// Build messages and collect corresponding entries
 	// When there's a compaction, we need to:
@@ -797,6 +827,9 @@ export function buildSessionContext(
 		serviceTier,
 		models,
 		injectedTtsrRules,
+		injectedTtsrRuleRecords: injectedTtsrRuleRecordsArray,
+		ttsrMessageCount,
+
 		selectedMCPToolNames,
 		hasPersistedMCPToolSelection,
 		mode,
@@ -810,6 +843,9 @@ function cloneSessionContext(context: SessionContext): SessionContext {
 		messages: cloneJsonSemantic(context.messages),
 		models: { ...context.models },
 		injectedTtsrRules: [...context.injectedTtsrRules],
+		injectedTtsrRuleRecords: context.injectedTtsrRuleRecords?.map(record => ({ ...record })),
+		ttsrMessageCount: context.ttsrMessageCount,
+
 		selectedMCPToolNames: [...context.selectedMCPToolNames],
 		modeData: cloneJsonSemantic(context.modeData),
 	};
@@ -1308,6 +1344,45 @@ function isImageBlock(value: unknown): value is { type: "image"; data: string; m
 	);
 }
 
+function stripUndefinedPlainObjectFields(value: unknown, path = "entry"): unknown {
+	if (value === undefined) return undefined;
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) {
+		let changed = false;
+		const result: unknown[] = new Array(value.length);
+		for (let index = 0; index < value.length; index++) {
+			const item = value[index];
+			if (item === undefined) {
+				throw new Error(`Session entry contains undefined array item at ${path}[${index}]`);
+			}
+			const next = stripUndefinedPlainObjectFields(item, `${path}[${index}]`);
+			if (next !== item) changed = true;
+			result[index] = next;
+		}
+		return changed ? result : value;
+	}
+
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+
+	let changed = false;
+	const entries: Array<readonly [string, unknown]> = [];
+	for (const [key, item] of Object.entries(value)) {
+		if (item === undefined) {
+			changed = true;
+			continue;
+		}
+		const next = stripUndefinedPlainObjectFields(item, `${path}.${key}`);
+		if (next !== item) changed = true;
+		entries.push([key, next]);
+	}
+	return changed ? Object.fromEntries(entries) : value;
+}
+
+function normalizeSessionEntryForStorage(entry: SessionEntry): SessionEntry {
+	return stripUndefinedPlainObjectFields(entry) as SessionEntry;
+}
+
 const RESIDENT_EXTERNALIZE_STRING_EXCLUDED_KEYS = new Set([
 	"id",
 	"type",
@@ -1461,9 +1536,25 @@ function materializeResidentEntrySync<T extends FileEntry | SessionEntry>(
 function materializeResidentEntriesSync<T extends FileEntry | SessionEntry>(
 	entries: T[],
 	stores: ResidentBlobStores,
+	missingPolicy: ResidentBlobMissingPolicy = "throw",
 ): T[] {
 	const cache = new Map<string, string>();
-	return entries.map(entry => materializeResidentEntrySync(entry, stores, cache));
+	return entries.map(entry => materializeResidentEntrySync(entry, stores, cache, missingPolicy));
+}
+
+function materializeResidentEntryForReadSync<T extends FileEntry | SessionEntry>(
+	entry: T,
+	stores: ResidentBlobStores,
+	cache: Map<string, string>,
+): T {
+	return materializeResidentEntrySync(entry, stores, cache, "placeholder");
+}
+
+function materializeResidentEntriesForReadSync<T extends FileEntry | SessionEntry>(
+	entries: T[],
+	stores: ResidentBlobStores,
+): T[] {
+	return materializeResidentEntriesSync(entries, stores, "placeholder");
 }
 
 function materializeResidentEntryForPersistenceSync<T extends FileEntry | SessionEntry>(
@@ -1520,12 +1611,24 @@ function cloneSessionEntry(entry: SessionEntry): SessionEntry {
 function materializeProviderVisibleEntrySync(entry: SessionEntry, stores: ResidentBlobStores): SessionEntry {
 	if (entry.type === "compaction") {
 		const cache = new Map<string, string>();
-		const summary = materializeResidentValueSync(entry.summary, stores, "summary", cache);
-		const shortSummary = materializeResidentValueSync(entry.shortSummary, stores, "shortSummary", cache);
+		const summary = materializeResidentValueSync(entry.summary, stores, "summary", cache, "placeholder");
+		const shortSummary = materializeResidentValueSync(
+			entry.shortSummary,
+			stores,
+			"shortSummary",
+			cache,
+			"placeholder",
+		);
 		const remote = entry.preserveData?.openaiRemoteCompaction;
 		const remoteRecord = isRecord(remote) ? remote : undefined;
 		const replacementHistory = remoteRecord
-			? materializeResidentValueSync(remoteRecord.replacementHistory, stores, "replacementHistory", cache)
+			? materializeResidentValueSync(
+					remoteRecord.replacementHistory,
+					stores,
+					"replacementHistory",
+					cache,
+					"placeholder",
+				)
 			: undefined;
 		const preserveData =
 			remoteRecord && replacementHistory !== undefined && replacementHistory !== remoteRecord.replacementHistory
@@ -1545,7 +1648,13 @@ function materializeProviderVisibleEntrySync(entry: SessionEntry, stores: Reside
 		};
 	}
 	if (entry.type === "branch_summary") {
-		const summary = materializeResidentValueSync(entry.summary, stores, "summary", new Map<string, string>());
+		const summary = materializeResidentValueSync(
+			entry.summary,
+			stores,
+			"summary",
+			new Map<string, string>(),
+			"placeholder",
+		);
 		return typeof summary === "string" ? { ...entry, summary } : { ...entry };
 	}
 	return cloneSessionEntry(entry);
@@ -2220,10 +2329,12 @@ class NdjsonFileWriter {
 	}
 }
 
+const DEFAULT_WELCOME_RECENT_SESSION_LIMIT = 20;
+
 /** Get recent sessions for display in welcome screen */
 export async function getRecentSessions(
 	sessionDir: string,
-	limit = 3,
+	limit = DEFAULT_WELCOME_RECENT_SESSION_LIMIT,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<RecentSessionInfo[]> {
 	const sessions = await getSortedSessions(sessionDir, storage);
@@ -2751,7 +2862,10 @@ export class SessionManager {
 	}
 
 	captureState(): SessionManagerStateSnapshot {
-		const materializedFileEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+		const materializedFileEntries = materializeResidentEntriesForReadSync(
+			this.#fileEntries,
+			this.#residentBlobStores(),
+		);
 		return {
 			sessionId: this.#sessionId,
 			sessionName: this.#sessionName,
@@ -2875,7 +2989,7 @@ export class SessionManager {
 
 		const oldSessionFile = this.#sessionFile;
 		const oldSessionId = this.#sessionId;
-		const materializedEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+		const materializedEntries = materializeResidentEntriesForReadSync(this.#fileEntries, this.#residentBlobStores());
 
 		// Close the current writer
 		await this.#closePersistWriter();
@@ -2947,7 +3061,10 @@ export class SessionManager {
 			hadSessionFile = this.storage.existsSync(oldSessionFile);
 			let movedSessionFile = false;
 			let movedArtifactDir = false;
-			const materializedEntries = materializeResidentEntriesSync(this.#fileEntries, this.#residentBlobStores());
+			const materializedEntries = materializeResidentEntriesForReadSync(
+				this.#fileEntries,
+				this.#residentBlobStores(),
+			);
 			const restoreResidentStateAfterFailure = (): void => {
 				this.#fileEntries = materializedEntries;
 				this.#resetResidentTextBlobStore();
@@ -3694,7 +3811,8 @@ export class SessionManager {
 	}
 
 	#appendEntry(entry: SessionEntry): void {
-		const residentEntry = prepareEntryForResidentSync(entry, this.#residentBlobStores()) as SessionEntry;
+		const normalizedEntry = normalizeSessionEntryForStorage(entry);
+		const residentEntry = prepareEntryForResidentSync(normalizedEntry, this.#residentBlobStores()) as SessionEntry;
 		this.#fileEntries.push(residentEntry);
 		this.#byId.set(residentEntry.id, residentEntry);
 		this.#leafId = residentEntry.id;
@@ -3875,6 +3993,25 @@ export class SessionManager {
 		return entry.id;
 	}
 
+	/**
+	 * Append a root marker that starts a fresh active branch without changing the
+	 * session id or deleting earlier durable entries. Subsequent messages descend
+	 * from this marker, so provider context is clear while history remains
+	 * available for diagnostics/export.
+	 */
+	appendContextClearEntry(data?: Record<string, unknown>): string {
+		const entry: CustomEntry = {
+			type: "custom",
+			customType: "context_clear",
+			data,
+			id: generateId(this.#byId),
+			parentId: null,
+			timestamp: new Date().toISOString(),
+		};
+		this.#appendEntry(entry);
+		return entry.id;
+	}
+
 	/**
 	 * Write mutated message entries back into the canonical entry store by id.
 	 *
@@ -3966,13 +4103,15 @@ export class SessionManager {
 	 * @param ruleNames Names of rules that were injected
 	 * @returns Entry id
 	 */
-	appendTtsrInjection(ruleNames: string[]): string {
+	appendTtsrInjection(ruleNames: string[], records?: TtsrInjectionRecord[], ttsrMessageCount?: number): string {
 		const entry: TtsrInjectionEntry = {
 			type: "ttsr_injection",
 			id: generateId(this.#byId),
 			parentId: this.#leafId,
 			timestamp: new Date().toISOString(),
 			injectedRules: ruleNames,
+			injectedRuleRecords: records,
+			ttsrMessageCount,
 		};
 		this.#appendEntry(entry);
 		return entry.id;
@@ -4006,7 +4145,7 @@ export class SessionManager {
 	getLeafEntry(): SessionEntry | undefined {
 		if (!this.#leafId) return undefined;
 		const entry = this.#byId.get(this.#leafId);
-		return entry ? materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()) : undefined;
+		return entry ? materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()) : undefined;
 	}
 
 	/**
@@ -4176,7 +4315,7 @@ export class SessionManager {
 		const entry = this.#byId.get(id);
 		return entry
 			? rehydrateColdSpillEntry(
-					materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()),
+					materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				)
@@ -4193,7 +4332,7 @@ export class SessionManager {
 			visited.add(current.id);
 			path.push(
 				rehydrateColdSpillEntry(
-					materializeResidentEntrySync(current, this.#residentBlobStores(), cache),
+					materializeResidentEntryForReadSync(current, this.#residentBlobStores(), cache),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				),
@@ -4233,7 +4372,7 @@ export class SessionManager {
 			.filter((entry): entry is SessionEntry => entry.type !== "session")
 			.map(entry =>
 				rehydrateColdSpillEntry(
-					materializeResidentEntrySync(entry, this.#residentBlobStores(), cache),
+					materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), cache),
 					this.#blobStore,
 					this.#residentBlobStoresForColdRehydrate(),
 				),
@@ -4244,7 +4383,7 @@ export class SessionManager {
 		this.#publicMaterializerCallCount++;
 		this.#getEntryMaterializerCallCount++;
 		const entry = this.#byId.get(id);
-		return entry ? materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map()) : undefined;
+		return entry ? materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map()) : undefined;
 	}
 
 	/**
@@ -4255,7 +4394,7 @@ export class SessionManager {
 		const children: SessionEntry[] = [];
 		for (const entry of this.#byId.values()) {
 			if (entry.parentId === parentId) {
-				children.push(materializeResidentEntrySync(entry, this.#residentBlobStores(), cache));
+				children.push(materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), cache));
 			}
 		}
 		return children;
@@ -4310,7 +4449,7 @@ export class SessionManager {
 		while (current) {
 			if (visited.has(current.id)) break;
 			visited.add(current.id);
-			path.push(materializeResidentEntrySync(current, this.#residentBlobStores(), cache));
+			path.push(materializeResidentEntryForReadSync(current, this.#residentBlobStores(), cache));
 			current = current.parentId ? this.#byId.get(current.parentId) : undefined;
 		}
 		path.reverse();
@@ -4375,7 +4514,7 @@ export class SessionManager {
 		}
 		if (entry.type !== "message" && entry.type !== "custom_message")
 			return materializeProviderVisibleEntrySync(entry, this.#residentBlobStores());
-		const materialized = materializeResidentEntrySync(entry, this.#residentBlobStores(), new Map());
+		const materialized = materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), new Map());
 		const rehydrated = rehydrateColdSpillEntry(
 			materialized,
 			this.#blobStore,
@@ -4434,7 +4573,7 @@ export class SessionManager {
 		const resolvedTextBlobCache = new Map<string, string>();
 		const materializedEntries = this.#fileEntries
 			.filter((e): e is SessionEntry => e.type !== "session")
-			.map(entry => materializeResidentEntrySync(entry, this.#residentBlobStores(), resolvedTextBlobCache));
+			.map(entry => materializeResidentEntryForReadSync(entry, this.#residentBlobStores(), resolvedTextBlobCache));
 		this.#materializedEntriesCache = materializedEntries;
 		this.#materializedEntriesRevision = this.#entryRevision;
 		return materializedEntries;
@@ -4591,7 +4730,7 @@ export class SessionManager {
 
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
 		const pathWithoutLabels = branchPath.filter(e => e.type !== "label");
-		const materializedPathWithoutLabels = materializeResidentEntriesSync(
+		const materializedPathWithoutLabels = materializeResidentEntriesForReadSync(
 			pathWithoutLabels,
 			this.#residentBlobStores(),
 		);