@adhdev/daemon-core 0.7.45 → 0.8.0

package/src/commands/router.ts

@@ -13,12 +13,15 @@ import { DaemonCdpManager } from '../cdp/manager.js';
 import { registerExtensionProviders } from '../cdp/setup.js';
 import { DaemonCommandHandler } from './handler.js';
 import { DaemonCliManager } from './cli-manager.js';
+import { supportsExplicitSessionResume } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
 import { loadConfig, saveConfig, updateConfig } from '../config/config.js';
 import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
-import { appendRecentActivity, markSessionSeen } from '../config/recent-activity.js';
+import { appendRecentActivity, getRecentActivity, markSessionSeen } from '../config/recent-activity.js';
+import { getSavedProviderSessions } from '../config/saved-sessions.js';
+import { listSavedHistorySessions } from '../config/chat-history.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
@@ -155,6 +158,54 @@ export class DaemonCommandRouter {
                 }
             }
 
+            case 'list_saved_sessions': {
+                const providerType = typeof args?.providerType === 'string'
+                    ? args.providerType.trim()
+                    : typeof args?.agentType === 'string'
+                        ? args.agentType.trim()
+                        : '';
+                const kind = args?.kind === 'acp' ? 'acp' : 'cli';
+                if (!providerType) {
+                    return { success: false, error: 'providerType required' };
+                }
+
+                const offset = Math.max(0, Number(args?.offset) || 0);
+                const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
+                const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
+                const config = loadConfig();
+                const savedSessions = getSavedProviderSessions(config, { providerType, kind });
+                const recentSessions = getRecentActivity(config, 200)
+                    .filter(entry => entry.providerType === providerType && entry.kind === kind && entry.providerSessionId);
+                const savedSessionById = new Map(savedSessions.map(entry => [entry.providerSessionId, entry]));
+                const recentSessionById = new Map(recentSessions.map(entry => [entry.providerSessionId!, entry]));
+                const providerMeta = this.deps.providerLoader.getMeta(providerType);
+                const canResumeById = supportsExplicitSessionResume(providerMeta?.resume);
+
+                return {
+                    success: true,
+                    sessions: historySessions.map(session => {
+                        const saved = savedSessionById.get(session.historySessionId);
+                        const recent = recentSessionById.get(session.historySessionId);
+                        return {
+                            id: session.historySessionId,
+                            providerSessionId: session.historySessionId,
+                            providerType,
+                            providerName: saved?.providerName || recent?.providerName || providerType,
+                            kind: saved?.kind || recent?.kind || kind,
+                            title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
+                            workspace: saved?.workspace || recent?.workspace,
+                            currentModel: saved?.currentModel || recent?.currentModel,
+                            preview: session.preview,
+                            messageCount: session.messageCount,
+                            firstMessageAt: session.firstMessageAt,
+                            lastMessageAt: session.lastMessageAt,
+                            canResume: !!(saved?.workspace || recent?.workspace) && canResumeById,
+                        };
+                    }),
+                    hasMore,
+                };
+            }
+
             // ─── restart_session: IDE / CLI / ACP unified ───
             case 'restart_session': {
                 const targetType = args?.cliType || args?.agentType || args?.ideType;

package/src/config/chat-history.ts

@@ -21,11 +21,23 @@ interface HistoryMessage {
     receivedAt: number;   // epoch ms
     role: 'user' | 'assistant' | 'system';
     content: string;
+    kind?: string;
+    senderName?: string;
     agent: string;        // e.g. 'antigravity', 'cursor', 'gemini-cli'
     instanceId?: string;  // IDE instance UUID (distinguishes windows of the same agent type)
+    historySessionId?: string; // Persistent provider-side conversation/session key
     sessionTitle?: string;
 }
 
+export interface SavedHistorySessionSummary {
+    historySessionId: string;
+    sessionTitle?: string;
+    messageCount: number;
+    firstMessageAt: number;
+    lastMessageAt: number;
+    preview?: string;
+}
+
 export class ChatHistoryWriter {
 /** Last seen message count per agent (deduplication) */
     private lastSeenCounts = new Map<string, number>();
@@ -43,15 +55,17 @@ export class ChatHistoryWriter {
  */
     appendNewMessages(
         agentType: string,
-        messages: Array<{ role: string; content: string; receivedAt?: number }>,
+        messages: Array<{ role: string; content: string; receivedAt?: number; kind?: string; senderName?: string; historyDedupKey?: string }>,
         sessionTitle?: string,
         instanceId?: string,
+        historySessionId?: string,
     ): void {
         if (!messages || messages.length === 0) return;
 
         try {
- // dedup key: agentType + instanceId
-            const dedupKey = instanceId ? `${agentType}:${instanceId}` : agentType;
+ // dedup key: agentType + persistent history key (fallback: runtime instanceId)
+            const effectiveHistoryKey = historySessionId || instanceId;
+            const dedupKey = effectiveHistoryKey ? `${agentType}:${effectiveHistoryKey}` : agentType;
             let seenHashes = this.lastSeenHashes.get(dedupKey);
             if (!seenHashes) {
                 seenHashes = new Set<string>();
@@ -61,7 +75,7 @@ export class ChatHistoryWriter {
  // Filter new messages
             const newMessages: HistoryMessage[] = [];
             for (const msg of messages) {
-                const hash = `${msg.role}:${(msg.content || '').slice(0, 50)}`;
+                const hash = msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`;
                 if (seenHashes.has(hash)) continue;
                 seenHashes.add(hash);
                 newMessages.push({
@@ -69,20 +83,23 @@ export class ChatHistoryWriter {
                     receivedAt: msg.receivedAt || Date.now(),
                     role: msg.role as 'user' | 'assistant' | 'system',
                     content: msg.content || '',
+                    kind: typeof msg.kind === 'string' ? msg.kind : undefined,
+                    senderName: typeof msg.senderName === 'string' ? msg.senderName : undefined,
                     agent: agentType,
                     instanceId,
+                    historySessionId: effectiveHistoryKey,
                     sessionTitle,
                 });
             }
 
             if (newMessages.length === 0) return;
 
- // Append to file — separate file if instanceId exists
+ // Append to file — keyed by persistent history session when available
             const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
             fs.mkdirSync(dir, { recursive: true });
 
             const date = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
-            const filePrefix = instanceId ? `${this.sanitize(instanceId)}_` : '';
+            const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : '';
             const filePath = path.join(dir, `${filePrefix}${date}.jsonl`);
             const lines = newMessages.map(m => JSON.stringify(m)).join('\n') + '\n';
             fs.appendFileSync(filePath, lines, 'utf-8');
@@ -92,7 +109,7 @@ export class ChatHistoryWriter {
             if (messages.length < prevCount * 0.5 && prevCount > 3) {
                 seenHashes.clear();
                 for (const msg of messages) {
-                    seenHashes.add(`${msg.role}:${(msg.content || '').slice(0, 50)}`);
+                    seenHashes.add(msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`);
                 }
             }
             this.lastSeenCounts.set(dedupKey, messages.length);
@@ -107,6 +124,103 @@ export class ChatHistoryWriter {
         }
     }
 
+    appendSystemMarker(
+        agentType: string,
+        content: string,
+        options: {
+            sessionTitle?: string;
+            instanceId?: string;
+            historySessionId?: string;
+            dedupKey?: string;
+            receivedAt?: number;
+            senderName?: string;
+        } = {},
+    ): void {
+        this.appendNewMessages(
+            agentType,
+            [{
+                role: 'system',
+                kind: 'system',
+                content,
+                receivedAt: options.receivedAt,
+                senderName: options.senderName,
+                historyDedupKey: options.dedupKey,
+            }],
+            options.sessionTitle,
+            options.instanceId,
+            options.historySessionId,
+        );
+    }
+
+    promoteHistorySession(
+        agentType: string,
+        previousHistorySessionId: string,
+        nextHistorySessionId: string,
+    ): void {
+        const fromId = String(previousHistorySessionId || '').trim();
+        const toId = String(nextHistorySessionId || '').trim();
+        if (!fromId || !toId || fromId === toId) return;
+
+        try {
+            const fromDedupKey = `${agentType}:${fromId}`;
+            const toDedupKey = `${agentType}:${toId}`;
+            const fromHashes = this.lastSeenHashes.get(fromDedupKey);
+            if (fromHashes?.size) {
+                const nextHashes = this.lastSeenHashes.get(toDedupKey) || new Set<string>();
+                for (const hash of fromHashes) nextHashes.add(hash);
+                this.lastSeenHashes.set(toDedupKey, nextHashes);
+                this.lastSeenHashes.delete(fromDedupKey);
+            }
+            const fromCount = this.lastSeenCounts.get(fromDedupKey);
+            if (typeof fromCount === 'number') {
+                this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
+                this.lastSeenCounts.delete(fromDedupKey);
+            }
+
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            if (!fs.existsSync(dir)) return;
+
+            const fromPrefix = `${this.sanitize(fromId)}_`;
+            const toPrefix = `${this.sanitize(toId)}_`;
+            const files = fs.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith('.jsonl'));
+
+            for (const file of files) {
+                const sourcePath = path.join(dir, file);
+                const targetPath = path.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
+                const sourceLines = fs.readFileSync(sourcePath, 'utf-8').split('\n').filter(Boolean);
+                const rewritten = sourceLines
+                    .map((line) => {
+                        try {
+                            const parsed = JSON.parse(line) as HistoryMessage;
+                            if (parsed.historySessionId !== fromId) return null;
+                            return JSON.stringify({
+                                ...parsed,
+                                historySessionId: toId,
+                            });
+                        } catch {
+                            return null;
+                        }
+                    })
+                    .filter((line): line is string => !!line);
+                if (rewritten.length === 0) {
+                    fs.unlinkSync(sourcePath);
+                    continue;
+                }
+
+                const existing = fs.existsSync(targetPath)
+                    ? new Set(fs.readFileSync(targetPath, 'utf-8').split('\n').filter(Boolean))
+                    : new Set<string>();
+                const nextLines = rewritten.filter((line) => !existing.has(line));
+                if (nextLines.length > 0) {
+                    fs.appendFileSync(targetPath, `${nextLines.join('\n')}\n`, 'utf-8');
+                }
+                fs.unlinkSync(sourcePath);
+            }
+        } catch {
+            // Ignore promotion failure; future messages will still write to the new session key.
+        }
+    }
+
 /** Called when agent session is explicitly changed */
     onSessionChange(agentType: string): void {
         this.lastSeenHashes.delete(agentType);
@@ -157,15 +271,15 @@ export function readChatHistory(
     agentType: string,
     offset: number = 0,
     limit: number = 30,
-    instanceId?: string,
+    historySessionId?: string,
 ): { messages: HistoryMessage[]; hasMore: boolean } {
     try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, '_');
         const dir = path.join(HISTORY_DIR, sanitized);
         if (!fs.existsSync(dir)) return { messages: [], hasMore: false };
 
- // JSONL file list — filter by instanceId prefix if specified
-        const sanitizedInstance = instanceId?.replace(/[^a-zA-Z0-9_-]/g, '_');
+ // JSONL file list — filter by persistent history key when specified
+        const sanitizedInstance = historySessionId?.replace(/[^a-zA-Z0-9_-]/g, '_');
         const files = fs.readdirSync(dir)
             .filter(f => {
                 if (!f.endsWith('.jsonl')) return false;
@@ -210,3 +324,76 @@ export function readChatHistory(
         return { messages: [], hasMore: false };
     }
 }
+
+export function listSavedHistorySessions(
+    agentType: string,
+    options: { offset?: number; limit?: number } = {},
+): { sessions: SavedHistorySessionSummary[]; hasMore: boolean } {
+    try {
+        const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const dir = path.join(HISTORY_DIR, sanitized);
+        if (!fs.existsSync(dir)) return { sessions: [], hasMore: false };
+
+        const groupedFiles = new Map<string, string[]>();
+        const filePattern = /^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/;
+        for (const file of fs.readdirSync(dir)) {
+            if (!file.endsWith('.jsonl')) continue;
+            const match = file.match(filePattern);
+            if (!match?.[1]) continue;
+            const historySessionId = match[1];
+            const files = groupedFiles.get(historySessionId) || [];
+            files.push(file);
+            groupedFiles.set(historySessionId, files);
+        }
+
+        const summaries: SavedHistorySessionSummary[] = [];
+        for (const [historySessionId, files] of groupedFiles.entries()) {
+            let messageCount = 0;
+            let firstMessageAt = 0;
+            let lastMessageAt = 0;
+            let sessionTitle = '';
+            let preview = '';
+
+            for (const file of files.sort()) {
+                const filePath = path.join(dir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const lines = content.split('\n').filter(Boolean);
+                for (const line of lines) {
+                    let parsed: HistoryMessage | null = null;
+                    try {
+                        parsed = JSON.parse(line) as HistoryMessage;
+                    } catch {
+                        parsed = null;
+                    }
+                    if (!parsed || parsed.historySessionId !== historySessionId) continue;
+                    messageCount += 1;
+                    if (!firstMessageAt || parsed.receivedAt < firstMessageAt) firstMessageAt = parsed.receivedAt;
+                    if (!lastMessageAt || parsed.receivedAt > lastMessageAt) lastMessageAt = parsed.receivedAt;
+                    if (parsed.sessionTitle) sessionTitle = parsed.sessionTitle;
+                    if (parsed.role !== 'system' && parsed.content.trim()) preview = parsed.content.trim();
+                }
+            }
+
+            if (messageCount === 0 || !lastMessageAt) continue;
+            summaries.push({
+                historySessionId,
+                sessionTitle: sessionTitle || undefined,
+                messageCount,
+                firstMessageAt,
+                lastMessageAt,
+                preview: preview || undefined,
+            });
+        }
+
+        summaries.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+        const offset = Math.max(0, options.offset || 0);
+        const limit = Math.max(1, options.limit || 30);
+        const sliced = summaries.slice(offset, offset + limit);
+        return {
+            sessions: sliced,
+            hasMore: summaries.length > offset + limit,
+        };
+    } catch {
+        return { sessions: [], hasMore: false };
+    }
+}

package/src/config/config.d.ts

@@ -5,8 +5,10 @@
  */
 import type { WorkspaceEntry } from './workspaces.js';
 import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
+export type { SavedProviderSessionEntry } from './saved-sessions.js';
 export interface ADHDevConfig {
     serverUrl: string;
     selectedIde: string | null;
@@ -23,6 +25,8 @@ export interface ADHDevConfig {
     defaultWorkspaceId?: string | null;
     /** Unified recent activity across IDE / CLI / ACP launch flows */
     recentActivity?: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions?: SavedProviderSessionEntry[];
     /** Last seen timestamps for live sessions, keyed by sessionId */
     sessionReads?: Record<string, number>;
     /** Last seen completion marker for live sessions, keyed by sessionId */

package/src/config/config.ts

@@ -10,8 +10,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'f
 import { randomUUID } from 'crypto';
 import type { WorkspaceEntry } from './workspaces.js';
 import type { RecentActivityEntry } from './recent-activity.js';
+import type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
+export type { SavedProviderSessionEntry } from './saved-sessions.js';
 
 export interface ADHDevConfig {
  // Server connection
@@ -44,6 +46,8 @@ export interface ADHDevConfig {
 
     /** Unified recent activity across IDE / CLI / ACP launch flows */
     recentActivity?: RecentActivityEntry[];
+    /** Persistent resume-capable provider sessions keyed by providerSessionId */
+    savedProviderSessions?: SavedProviderSessionEntry[];
     /** Last seen timestamps for live sessions, keyed by sessionId */
     sessionReads?: Record<string, number>;
     /** Last seen completion marker for live sessions, keyed by sessionId */
@@ -65,7 +69,7 @@ export interface ADHDevConfig {
      * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
      * `POST /cli/complete`. Used as fallback for machine lookup on re-auth.
      *
-     * @deprecated Legacy bridge field — will be removed after 2026-04-06.
+     * @deprecated Legacy bridge field — will be removed after 2026-05-01.
      * Modern auth flow uses `machineSecret` (adm_) to identify machines.
      */
     registeredMachineId?: string;
@@ -99,6 +103,7 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     workspaces: [],
     defaultWorkspaceId: null,
     recentActivity: [],
+    savedProviderSessions: [],
     sessionReads: {},
     sessionReadMarkers: {},
     machineNickname: null,
@@ -161,6 +166,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces as WorkspaceEntry[] : [],
         defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
         recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity as RecentActivityEntry[] : [],
+        savedProviderSessions: Array.isArray(parsed.savedProviderSessions) ? parsed.savedProviderSessions as SavedProviderSessionEntry[] : [],
         sessionReads: mergedSessionReads,
         sessionReadMarkers,
         machineNickname: asNullableString(parsed.machineNickname),
@@ -187,7 +193,7 @@ function ensureMachineId(config: ADHDevConfig): { config: ADHDevConfig; changed:
         return { config, changed: false };
     }
 
-    // TODO(2026-04-06): Remove this legacy bridge after cloud clients have had
+    // TODO(2026-05-01): Remove this legacy bridge after cloud clients have had
     // time to persist registeredMachineId from the upgraded setup/login flow.
     const legacyRegisteredMachineId = (!config.registeredMachineId && config.machineSecret && config.machineId)
         ? config.machineId

package/src/config/recent-activity.ts

@@ -3,7 +3,7 @@
  *
  * Unlike live session state, this is launch oriented:
  * - one normalized row shape for IDE / CLI / ACP
- * - deduped by kind + providerType + workspace
+ * - deduped by provider session when available, else by kind + providerType + workspace
  * - used only for quick-launch shortcuts
  */
 
@@ -16,6 +16,7 @@ export interface RecentActivityEntry {
     kind: 'ide' | 'cli' | 'acp';
     providerType: string;
     providerName: string;
+    providerSessionId?: string;
     workspace?: string | null;
     currentModel?: string;
     title?: string;
@@ -37,6 +38,16 @@ export function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' |
     return `${entry.kind}:${entry.providerType}:${normalizeWorkspace(entry.workspace)}`;
 }
 
+export function buildRecentActivityKeyForEntry(
+    entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace' | 'providerSessionId'>,
+) {
+    const providerSessionId = typeof entry.providerSessionId === 'string' ? entry.providerSessionId.trim() : '';
+    if (providerSessionId) {
+        return `${entry.kind}:${entry.providerType}:session:${providerSessionId}`;
+    }
+    return buildRecentActivityKey(entry);
+}
+
 export function appendRecentActivity(
     config: ADHDevConfig,
     entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & { lastUsedAt?: number },
@@ -44,7 +55,7 @@ export function appendRecentActivity(
     const nextEntry: RecentActivityEntry = {
         ...entry,
         workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : undefined,
-        id: buildRecentActivityKey(entry),
+        id: buildRecentActivityKeyForEntry(entry),
         lastUsedAt: entry.lastUsedAt || Date.now(),
     };
 

package/src/config/saved-sessions.ts

@@ -0,0 +1,73 @@
+import * as path from 'path';
+import type { ADHDevConfig } from './config.js';
+import { expandPath } from './workspaces.js';
+
+export interface SavedProviderSessionEntry {
+    id: string;
+    kind: 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    providerSessionId: string;
+    workspace?: string | null;
+    currentModel?: string;
+    title?: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+
+const MAX_SAVED_SESSIONS = 500;
+
+function normalizeWorkspace(workspace?: string | null) {
+    if (!workspace) return '';
+    try {
+        return path.resolve(expandPath(workspace));
+    } catch {
+        return path.resolve(workspace);
+    }
+}
+
+export function buildSavedProviderSessionKey(providerSessionId: string) {
+    return `saved:${providerSessionId.trim()}`;
+}
+
+export function upsertSavedProviderSession(
+    config: ADHDevConfig,
+    entry: Omit<SavedProviderSessionEntry, 'id' | 'createdAt' | 'lastUsedAt'> & { createdAt?: number; lastUsedAt?: number },
+): ADHDevConfig {
+    const providerSessionId = typeof entry.providerSessionId === 'string' ? entry.providerSessionId.trim() : '';
+    if (!providerSessionId) return config;
+
+    const id = buildSavedProviderSessionKey(providerSessionId);
+    const existing = (config.savedProviderSessions || []).find(item => item.id === id);
+    const nextEntry: SavedProviderSessionEntry = {
+        id,
+        kind: entry.kind,
+        providerType: entry.providerType,
+        providerName: entry.providerName,
+        providerSessionId,
+        workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : undefined,
+        currentModel: entry.currentModel,
+        title: entry.title,
+        createdAt: existing?.createdAt || entry.createdAt || Date.now(),
+        lastUsedAt: entry.lastUsedAt || Date.now(),
+    };
+
+    const filtered = (config.savedProviderSessions || []).filter(item => item.id !== id);
+    return {
+        ...config,
+        savedProviderSessions: [nextEntry, ...filtered].slice(0, MAX_SAVED_SESSIONS),
+    };
+}
+
+export function getSavedProviderSessions(
+    config: ADHDevConfig,
+    filters?: { providerType?: string; kind?: SavedProviderSessionEntry['kind'] },
+): SavedProviderSessionEntry[] {
+    return [...(config.savedProviderSessions || [])]
+        .filter(entry => {
+            if (filters?.providerType && entry.providerType !== filters.providerType) return false;
+            if (filters?.kind && entry.kind !== filters.kind) return false;
+            return true;
+        })
+        .sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+}