sidekick-shared 0.27.5 → 0.28.0

package/dist/esm/parsers/subagentTraceParser.js

@@ -0,0 +1,325 @@
+/**
+ * Subagent execution trace parser.
+ *
+ * Extends the existing subagent scanner to preserve full conversation events
+ * (not just stats) for drill-down trace visualization. Applies noise classification
+ * and tool summary formatting from the formatters module.
+ *
+ * Three-phase parent-child linking:
+ * 1. Result-based: match toolUseResult.agentId → parent tool_use_id
+ * 2. Team summary: parse <teammate-message> XML blocks
+ * 3. Positional fallback: timestamp ordering + proximity
+ *
+ * @module parsers/subagentTraceParser
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { formatToolSummary } from '../formatters/toolSummary';
+import { isHardNoise, classifyMessage, getSoftNoiseReason } from '../formatters/noiseClassifier';
+import { ClaudeUsageDeduper, dedupedRawClaudeUsage } from '../usage/claudeUsageDedupe';
+import { addUsageToSubagent } from '../usage/subagentUsage';
+import { readAgentMeta } from './subagentScanner';
+// ── Constants ──
+const AGENT_FILE_PATTERN = /^agent-(.+)\.jsonl$/;
+// ── Public API ──
+/**
+ * Scans and parses subagent traces with full conversation events.
+ *
+ * Unlike `scanSubagentDir()` which only returns stats, this returns
+ * the full conversation trace for each subagent, formatted with tool
+ * summaries and noise classification.
+ *
+ * @param sessionDir - Directory containing the session file
+ * @param sessionId - Session ID (filename without .jsonl extension)
+ * @returns Array of SubagentTrace objects forming a tree
+ */
+export function scanSubagentTraces(sessionDir, sessionId) {
+    const subagentsDir = path.join(sessionDir, sessionId, 'subagents');
+    try {
+        if (!fs.existsSync(subagentsDir))
+            return [];
+        const files = fs.readdirSync(subagentsDir);
+        const traces = [];
+        for (const file of files) {
+            const match = file.match(AGENT_FILE_PATTERN);
+            if (!match)
+                continue;
+            const agentId = match[1];
+            const filePath = path.join(subagentsDir, file);
+            const trace = parseAgentTrace(filePath, agentId);
+            if (trace)
+                traces.push(trace);
+        }
+        // Link parent-child relationships
+        linkTraces(traces);
+        // Return only top-level traces (those without parents)
+        return traces.filter((t) => !t.parentToolUseId);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Parsing ──
+function parseAgentTrace(filePath, agentId) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter((l) => l.trim());
+        const events = [];
+        const toolCalls = [];
+        let agentType;
+        let description;
+        const tokens = { agentId, toolCalls: [], inputTokens: 0, outputTokens: 0 };
+        const usageDeduper = new ClaudeUsageDeduper();
+        let startTime;
+        let endTime;
+        for (const line of lines) {
+            try {
+                const raw = JSON.parse(line);
+                const timestamp = new Date(raw.timestamp || Date.now());
+                if (!startTime)
+                    startTime = timestamp;
+                endTime = timestamp;
+                // Build SessionEvent from raw JSONL
+                const sessionEvent = rawToSessionEvent(raw);
+                if (!sessionEvent)
+                    continue;
+                // Classify and format
+                const hardNoise = isHardNoise(sessionEvent);
+                const messageClass = classifyMessage(sessionEvent);
+                const softNoise = getSoftNoiseReason(sessionEvent);
+                // Compute noise level
+                let noiseLevel = 'system';
+                switch (sessionEvent.type) {
+                    case 'user':
+                        noiseLevel = 'user';
+                        break;
+                    case 'assistant':
+                        noiseLevel = 'ai';
+                        break;
+                    case 'tool_use':
+                        noiseLevel = 'system';
+                        break;
+                    case 'tool_result':
+                        noiseLevel = 'noise';
+                        break;
+                    case 'summary':
+                        noiseLevel = 'system';
+                        break;
+                }
+                // Format tool summary
+                let toolSummary;
+                if (sessionEvent.tool) {
+                    toolSummary = formatToolSummary(sessionEvent.tool.name, sessionEvent.tool.input);
+                }
+                events.push({
+                    event: sessionEvent,
+                    toolSummary,
+                    noiseLevel,
+                    messageClassification: messageClass,
+                    softNoiseReason: softNoise ?? undefined,
+                    isHardNoise: hardNoise,
+                });
+                // Extract token usage
+                // Split lines of one response repeat its usage; count each response once.
+                const usage = dedupedRawClaudeUsage(raw, usageDeduper);
+                if (usage)
+                    addUsageToSubagent(tokens, usage);
+                // Extract tool calls
+                if (raw.type === 'assistant' && Array.isArray(raw.message?.content)) {
+                    for (const block of raw.message.content) {
+                        if (block?.type === 'tool_use') {
+                            toolCalls.push({
+                                name: block.name,
+                                input: block.input || {},
+                                timestamp,
+                            });
+                            // Extract agent info from Task tool
+                            if (block.name === 'Task' && block.input) {
+                                if (block.input.subagent_type && !agentType) {
+                                    agentType = String(block.input.subagent_type);
+                                }
+                                if (block.input.description && !description) {
+                                    description = String(block.input.description);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Extract agent type from system messages
+                if (raw.type === 'system' && raw.message?.content) {
+                    const contentStr = typeof raw.message.content === 'string'
+                        ? raw.message.content
+                        : JSON.stringify(raw.message.content);
+                    const typeMatch = contentStr.match(/subagent_type['":\s]+(\w+)/i);
+                    if (typeMatch && !agentType) {
+                        agentType = typeMatch[1];
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+        const meta = readAgentMeta(filePath);
+        agentType = meta.agentType ?? agentType;
+        description = meta.description ?? description;
+        if (events.length === 0 && !agentType && !description && !tokens.totalTokens) {
+            return null;
+        }
+        const durationMs = startTime && endTime ? endTime.getTime() - startTime.getTime() : undefined;
+        return {
+            agentId,
+            agentType,
+            description,
+            events,
+            children: [],
+            stats: {
+                agentId,
+                agentType,
+                description,
+                toolCalls,
+                inputTokens: tokens.inputTokens,
+                outputTokens: tokens.outputTokens,
+                cacheReadTokens: tokens.cacheReadTokens ?? 0,
+                cacheWriteTokens: tokens.cacheWriteTokens ?? 0,
+                reasoningTokens: tokens.reasoningTokens ?? 0,
+                totalTokens: tokens.totalTokens ?? 0,
+                startTime,
+                endTime,
+                durationMs,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Parent-Child Linking ──
+function linkTraces(traces) {
+    const traceById = new Map();
+    for (const trace of traces) {
+        traceById.set(trace.agentId, trace);
+    }
+    // Phase 1: Result-based linking
+    // Look for tool_result events that contain agentId references
+    for (const trace of traces) {
+        for (const traceEvent of trace.events) {
+            const evt = traceEvent.event;
+            if (evt.type === 'tool_use' && evt.tool?.name === 'Task') {
+                // The tool_use_id from this call should appear as a result in the parent
+                // but we can link via timestamp proximity to child traces
+            }
+        }
+    }
+    // Phase 2: Team summary linking
+    for (const trace of traces) {
+        for (const traceEvent of trace.events) {
+            const content = traceEvent.event.message?.content;
+            if (typeof content === 'string' && content.includes('<teammate-message>')) {
+                // Parse teammate agent IDs from XML blocks
+                const matches = content.matchAll(/agent[_-]id['":\s]+([a-f0-9]+)/gi);
+                for (const match of matches) {
+                    const childId = match[1];
+                    const child = traceById.get(childId);
+                    if (child && child !== trace && !child.parentToolUseId) {
+                        child.parentToolUseId = trace.agentId;
+                        trace.children.push(child);
+                    }
+                }
+            }
+        }
+    }
+    // Phase 3: Positional fallback — timestamp proximity
+    // Traces without parents that fall within another trace's time window
+    const parentless = traces.filter((t) => !t.parentToolUseId);
+    for (const child of parentless) {
+        if (!child.stats.startTime)
+            continue;
+        const childStart = child.stats.startTime.getTime();
+        // Find a trace that was active (Task tool call) right before this child started
+        for (const potential of traces) {
+            if (potential === child)
+                continue;
+            if (potential.parentToolUseId)
+                continue; // Already linked
+            for (const traceEvent of potential.events) {
+                const evt = traceEvent.event;
+                if (evt.type === 'assistant' && evt.tool?.name === 'Task') {
+                    const taskTime = new Date(evt.timestamp).getTime();
+                    // Within 2 seconds before child start
+                    if (taskTime <= childStart && childStart - taskTime < 2000) {
+                        child.parentToolUseId = potential.agentId;
+                        potential.children.push(child);
+                        break;
+                    }
+                }
+            }
+            if (child.parentToolUseId)
+                break;
+        }
+    }
+}
+// ── Helpers ──
+function rawToSessionEvent(raw) {
+    const type = raw.type;
+    if (!type)
+        return null;
+    // Map raw JSONL types to SessionEvent types
+    const typeMap = {
+        user: 'user',
+        assistant: 'assistant',
+        tool_use: 'tool_use',
+        tool_result: 'tool_result',
+        summary: 'summary',
+    };
+    const mappedType = typeMap[type];
+    if (!mappedType)
+        return null;
+    const message = raw.message;
+    const timestamp = raw.timestamp || new Date().toISOString();
+    // Extract tool info for tool_use events from content blocks
+    let tool;
+    let result;
+    if (mappedType === 'assistant' && message?.content && Array.isArray(message.content)) {
+        // Look for inline tool_use blocks
+        for (const block of message.content) {
+            if (block.type === 'tool_use') {
+                tool = {
+                    name: block.name,
+                    input: block.input || {},
+                };
+                break;
+            }
+        }
+    }
+    if (mappedType === 'tool_result') {
+        const msg = raw.message;
+        if (msg?.content && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'tool_result') {
+                    result = {
+                        tool_use_id: block.tool_use_id,
+                        output: block.content,
+                        is_error: block.is_error,
+                    };
+                    break;
+                }
+            }
+        }
+    }
+    const common = {
+        timestamp,
+        isSidechain: raw.isSidechain,
+        permissionMode: raw.permissionMode,
+    };
+    if (mappedType === 'user' || mappedType === 'assistant') {
+        return { ...common, type: mappedType, message: message || { role: 'unknown' }, tool };
+    }
+    if (mappedType === 'summary') {
+        return { ...common, type: 'summary', message: message || { role: 'summary' } };
+    }
+    if (mappedType === 'tool_use') {
+        return tool ? { ...common, type: 'tool_use', message, tool } : null;
+    }
+    return result ? { ...common, type: 'tool_result', message, result } : null;
+}

package/dist/esm/paths.js

@@ -0,0 +1,134 @@
+/**
+ * Config path resolution and workspace encoding.
+ * Mirrors patterns from sidekick-vscode/src/services/SessionPathResolver.ts
+ * and TaskPersistenceService.ts
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+/** Environment variable that redirects the Sidekick config root. */
+export const CONFIG_DIR_ENV_VAR = 'SIDEKICK_CONFIG_DIR';
+let configDirOverride = null;
+/**
+ * The platform default config directory, ignoring both {@link setConfigDir}
+ * and `SIDEKICK_CONFIG_DIR`.
+ *
+ * `~/.config/sidekick` on Unix, `%APPDATA%/sidekick` on Windows.
+ */
+export function getDefaultConfigDir() {
+    if (process.platform === 'win32') {
+        return path.join(process.env.APPDATA || os.homedir(), 'sidekick');
+    }
+    return path.join(os.homedir(), '.config', 'sidekick');
+}
+/**
+ * Redirect the Sidekick config root for this process.
+ *
+ * Takes precedence over `SIDEKICK_CONFIG_DIR`. Pass `null` (or an empty
+ * string) to clear it. Every reader and writer in the package resolves the
+ * root lazily through {@link getConfigDir}, so this takes effect immediately
+ * for all of them — including transitive callers of `getProjectDataPath`,
+ * `getGlobalDataPath`, and the account registry.
+ *
+ * Prefer `SIDEKICK_CONFIG_DIR` when the value is known before the process
+ * starts: it is read fresh on every call, so it stays correct even if a
+ * bundler ends up with more than one copy of this module.
+ *
+ * @example
+ * setConfigDir(path.join(os.tmpdir(), 'sidekick-fixture'));
+ * try {
+ *   await addTask(project, { subject: 'isolated' });
+ * } finally {
+ *   setConfigDir(null);
+ * }
+ */
+export function setConfigDir(dir) {
+    // Resolve the trimmed value, not the original: `path.resolve('  /tmp/x  ')`
+    // treats the leading spaces as a relative segment and lands under cwd. The
+    // `SIDEKICK_CONFIG_DIR` branch in getConfigDir() already trims, and the two
+    // routes are documented as interchangeable.
+    const trimmed = dir?.trim();
+    configDirOverride = trimmed ? path.resolve(trimmed) : null;
+}
+/** The active {@link setConfigDir} override, or `null` when unset. */
+export function getConfigDirOverride() {
+    return configDirOverride;
+}
+/**
+ * Gets the Sidekick config directory.
+ *
+ * Resolution order: {@link setConfigDir} override → `SIDEKICK_CONFIG_DIR`
+ * → {@link getDefaultConfigDir}.
+ */
+export function getConfigDir() {
+    if (configDirOverride)
+        return configDirOverride;
+    const fromEnv = process.env[CONFIG_DIR_ENV_VAR]?.trim();
+    if (fromEnv)
+        return path.resolve(fromEnv);
+    return getDefaultConfigDir();
+}
+/**
+ * Gets the path to a project-specific data file.
+ * e.g., ~/.config/sidekick/tasks/my-project.json
+ */
+export function getProjectDataPath(slug, subdomain) {
+    return path.join(getConfigDir(), subdomain, `${slug}.json`);
+}
+/**
+ * Gets the path to a global data file.
+ * e.g., ~/.config/sidekick/historical-data.json
+ */
+export function getGlobalDataPath(filename) {
+    return path.join(getConfigDir(), filename);
+}
+/**
+ * Encodes a workspace path into Sidekick's own config-store slug — path
+ * separators, colons, and underscores become hyphens, dots are kept.
+ *
+ * This is NOT Claude Code's `~/.claude/projects/` naming scheme, despite the
+ * shared name: Claude Code also replaces dots, spaces, and every other
+ * non-alphanumeric character. To locate Claude Code session directories use
+ * `encodeClaudeWorkspacePath` / `getClaudeSessionDirectory` from
+ * `parsers/sessionPathResolver` instead.
+ */
+export function encodeWorkspacePath(workspacePath) {
+    const normalized = workspacePath.replace(/\\/g, '/');
+    return normalized.replace(/[:/_]/g, '-');
+}
+/**
+ * Derives a project slug from a workspace path.
+ * Resolves symlinks, then encodes for use as a filename.
+ */
+export function getProjectSlug(cwd) {
+    return resolveProjectIdentity(cwd).canonicalSlug;
+}
+/** Resolves the canonical project identity used by all new readers and writers. */
+export function resolveProjectIdentity(cwd) {
+    const dir = path.resolve(cwd || process.cwd());
+    let resolved;
+    try {
+        resolved = fs.realpathSync(dir);
+    }
+    catch {
+        resolved = dir;
+    }
+    const canonicalSlug = encodeWorkspacePath(resolved);
+    const legacySlug = encodeWorkspacePath(dir);
+    return {
+        cwd: dir,
+        resolvedCwd: resolved,
+        canonicalSlug,
+        legacySlug,
+        candidates: canonicalSlug === legacySlug ? [canonicalSlug] : [canonicalSlug, legacySlug],
+        hasLegacyMismatch: canonicalSlug !== legacySlug,
+    };
+}
+/**
+ * Derives a project slug WITHOUT resolving symlinks.
+ * Matches the VS Code extension's behavior (encodeWorkspacePath on raw path).
+ * Use this when reading data written by the extension.
+ */
+export function getProjectSlugRaw(cwd) {
+    return resolveProjectIdentity(cwd).legacySlug;
+}

package/dist/esm/peakHours.js

@@ -0,0 +1,194 @@
+/**
+ * Stateless peak-hours fetcher for promoclock.co.
+ *
+ * PromoClock is a free, third-party tracker (maintained by @onursendere,
+ * not affiliated with Anthropic) that reports whether Claude's session
+ * limits are draining at normal or faster rate. Peak window is weekdays
+ * 13:00–19:00 UTC; session limits drain faster during that window for
+ * Free / Pro / Max / Team subscriptions.
+ *
+ * Polling / eventing is the caller's responsibility.
+ */
+const PROMOCLOCK_ENDPOINT = 'https://promoclock.co/api/status';
+/**
+ * Default budget for the promoclock.co request, in milliseconds. The schedule
+ * fallback answers the question anyway, so a slow third-party host should not
+ * hold up a `sidekick status` or `sidekick quota` run for long.
+ */
+export const DEFAULT_PEAK_HOURS_TIMEOUT_MS = 4_000;
+/** A promoclock.co answer is reused for this long before the host is asked again. */
+export const PEAK_HOURS_CACHE_MS = 10 * 60_000;
+/** Published peak window: weekdays 13:00–19:00 UTC. */
+export const PEAK_WINDOW_START_UTC_HOUR = 13;
+export const PEAK_WINDOW_END_UTC_HOUR = 19;
+export const PEAK_HOURS_DESCRIPTION = 'Weekdays 13:00–19:00 UTC';
+let cachedNetworkState = null;
+/** Forget the cached promoclock.co answer. Test-only. */
+export function _resetPeakHoursCache() {
+    cachedNetworkState = null;
+}
+function isWeekdayUtc(date) {
+    const day = date.getUTCDay();
+    return day >= 1 && day <= 5;
+}
+function utcDateAtHour(date, hour, dayOffset = 0) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + dayOffset, hour));
+}
+/**
+ * Peak-hours state computed from the published schedule alone, with no
+ * network access. Used directly by cache-only commands (`sidekick today`) and
+ * as the fallback when promoclock.co cannot be reached, so every surface
+ * agrees on whether it is currently peak.
+ */
+export function getScheduledPeakHoursState(now = new Date()) {
+    const hour = now.getUTCHours() + now.getUTCMinutes() / 60;
+    const isPeak = isWeekdayUtc(now) && hour >= PEAK_WINDOW_START_UTC_HOUR && hour < PEAK_WINDOW_END_UTC_HOUR;
+    let nextChange;
+    if (isPeak) {
+        nextChange = utcDateAtHour(now, PEAK_WINDOW_END_UTC_HOUR);
+    }
+    else if (isWeekdayUtc(now) && hour < PEAK_WINDOW_START_UTC_HOUR) {
+        nextChange = utcDateAtHour(now, PEAK_WINDOW_START_UTC_HOUR);
+    }
+    else {
+        let offset = 1;
+        while (!isWeekdayUtc(utcDateAtHour(now, 0, offset)))
+            offset += 1;
+        nextChange = utcDateAtHour(now, PEAK_WINDOW_START_UTC_HOUR, offset);
+    }
+    return {
+        status: isPeak ? 'peak' : 'off_peak',
+        isPeak,
+        sessionLimitSpeed: isPeak ? 'faster' : 'normal',
+        label: isPeak ? 'Peak Hours' : 'Off-Peak',
+        peakHoursDescription: PEAK_HOURS_DESCRIPTION,
+        nextChange: nextChange.toISOString(),
+        minutesUntilChange: Math.max(0, Math.round((nextChange.getTime() - now.getTime()) / 60_000)),
+        note: 'Computed from the published weekday schedule.',
+        updatedAt: now.toISOString(),
+        unavailable: false,
+        source: 'schedule',
+    };
+}
+function unavailableState() {
+    return {
+        status: 'unknown',
+        isPeak: false,
+        sessionLimitSpeed: 'unknown',
+        label: 'Peak-hours status unavailable',
+        peakHoursDescription: '',
+        nextChange: null,
+        minutesUntilChange: null,
+        note: '',
+        updatedAt: new Date().toISOString(),
+        unavailable: true,
+    };
+}
+const PROVIDER_DISPLAY_NAMES = {
+    'claude-code': 'Claude Code',
+    opencode: 'OpenCode',
+    codex: 'Codex CLI',
+};
+export function isClaudeCodeSessionProvider(providerId) {
+    return providerId === 'claude-code';
+}
+export function createPeakHoursNotApplicableState(providerId) {
+    const providerName = PROVIDER_DISPLAY_NAMES[providerId] ?? providerId;
+    return {
+        status: 'unknown',
+        isPeak: false,
+        sessionLimitSpeed: 'unknown',
+        label: 'Claude peak hours not applicable',
+        peakHoursDescription: '',
+        nextChange: null,
+        minutesUntilChange: null,
+        note: `Claude peak hours apply only to Claude Code sessions, not ${providerName}.`,
+        updatedAt: new Date().toISOString(),
+        unavailable: true,
+        notApplicable: true,
+    };
+}
+export function scopePeakHoursToSessionProvider(providerId, status) {
+    if (!isClaudeCodeSessionProvider(providerId))
+        return null;
+    return status ?? null;
+}
+function normalizeStatus(raw) {
+    if (raw === 'peak' || raw === 'off_peak')
+        return raw;
+    return 'unknown';
+}
+function normalizeSpeed(raw) {
+    if (raw === 'normal' || raw === 'faster')
+        return raw;
+    return 'unknown';
+}
+/**
+ * Fetch current Claude peak-hours state from promoclock.co.
+ *
+ * Single-shot — caller wraps in polling loop, EventEmitter, or interval.
+ * A successful answer is cached in-process for {@link PEAK_HOURS_CACHE_MS}.
+ * On any network, timeout, or parse error the state is computed from the
+ * published schedule instead (`source: 'schedule'`), so callers always get a
+ * usable answer and every surface agrees on it; {@link unavailableState} is
+ * only returned when the schedule itself cannot be evaluated.
+ *
+ * promoclock.co is a third-party host, so the request is always bounded by
+ * an abort timeout. Without one a hung host would stall the caller — and
+ * this is polled, so the stall would repeat.
+ */
+export async function fetchPeakHoursStatus(options = {}) {
+    const now = Date.now();
+    if (!options.force &&
+        cachedNetworkState &&
+        now - cachedNetworkState.fetchedAt < PEAK_HOURS_CACHE_MS) {
+        return cachedNetworkState.state;
+    }
+    const timeoutMs = options.timeoutMs ?? DEFAULT_PEAK_HOURS_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    timeout.unref();
+    try {
+        const res = await fetch(PROMOCLOCK_ENDPOINT, { signal: controller.signal });
+        if (!res.ok)
+            return scheduleFallback();
+        const data = await res.json();
+        const status = normalizeStatus(data.status);
+        const sessionLimitSpeed = normalizeSpeed(data.sessionLimitSpeed);
+        const isPeak = typeof data.isPeak === 'boolean' ? data.isPeak : status === 'peak';
+        const state = {
+            status,
+            isPeak,
+            sessionLimitSpeed,
+            label: data.label ?? (isPeak ? 'Peak Hours' : 'Off-Peak'),
+            peakHoursDescription: data.peakHours ?? '',
+            nextChange: data.nextChange ?? null,
+            minutesUntilChange: typeof data.minutesUntilChange === 'number' ? data.minutesUntilChange : null,
+            note: data.note ?? '',
+            updatedAt: data.timestamp ?? new Date().toISOString(),
+            unavailable: false,
+            source: 'promoclock',
+        };
+        cachedNetworkState = { state, fetchedAt: now };
+        return state;
+    }
+    catch {
+        // Covers AbortError from the timeout above alongside network/parse failures.
+        return scheduleFallback();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function scheduleFallback() {
+    try {
+        const state = getScheduledPeakHoursState();
+        return {
+            ...state,
+            note: 'promoclock.co unreachable; computed from the published weekday schedule.',
+        };
+    }
+    catch {
+        return unavailableState();
+    }
+}