0xray 4.0.36 → 4.0.38

package/dist/nucleus/synthesis-consult-receipt.js

@@ -72,24 +72,46 @@ export function hasValidSynthesisConsultReceipt(todoId, projectRoot = process.cw
         return false;
     return validateSynthesisConsultReceipt(receipt, todoId, expected);
 }
+function verdictFromToken(token) {
+    const value = token.toLowerCase();
+    if (value === 'approve' || value === 'approved' || value === 'pass')
+        return 'PASS';
+    if (value === 'reject' || value === 'rejected' || value === 'fail')
+        return 'FAIL';
+    if (value === 'abstain' ||
+        value === 'needs_revision' ||
+        value === 'conditional' ||
+        value === 'revise') {
+        return 'CONDITIONAL';
+    }
+    return null;
+}
+/** The last single Verdict or DECISION line wins. A menu line that lists every word does not. */
+function lastExplicitVerdict(text) {
+    let found = null;
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim().replace(/^[-*•]\s*/, '');
+        const match = trimmed.match(/^(?:Verdict|DECISION):\s*(\w+)/i);
+        const token = match?.[1];
+        if (!token || trimmed.includes('|'))
+            continue;
+        const verdict = verdictFromToken(token);
+        if (verdict)
+            found = verdict;
+    }
+    return found;
+}
 export function parseConsultVerdictFromText(text) {
-    const normalized = text.toUpperCase();
-    const decisionMatch = text.match(/\bDECISION:\s*(\w+)/i);
-    if (decisionMatch) {
-        const decision = decisionMatch[1].toLowerCase();
-        if (decision === 'approve' || decision === 'approved' || decision === 'pass') {
-            return 'PASS';
-        }
-        if (decision === 'reject' || decision === 'rejected' || decision === 'fail') {
-            return 'FAIL';
-        }
-        if (decision === 'abstain' ||
-            decision === 'needs_revision' ||
-            decision === 'conditional' ||
-            decision === 'revise') {
-            return 'CONDITIONAL';
-        }
+    const explicit = lastExplicitVerdict(text);
+    if (explicit)
+        return explicit;
+    const decisionToken = text.match(/\bDECISION:\s*(\w+)/i)?.[1];
+    if (decisionToken) {
+        const mapped = verdictFromToken(decisionToken);
+        if (mapped)
+            return mapped;
     }
+    const normalized = text.toUpperCase();
     if (/\bCONDITIONAL(\s+PASS)?\b/.test(normalized))
         return 'CONDITIONAL';
     if (/\b(?:PASS|SHIP|APPROVE)\b/.test(normalized))

package/dist/orchestrator/enhanced-multi-agent-orchestrator.d.ts

@@ -120,6 +120,11 @@ export declare class EnhancedMultiAgentOrchestrator {
      * Check for pending spawns that can now execute
      */
     private checkPendingSpawns;
+    /**
+     * Lookup one monitored agent without copying every spawn map.
+     * Precedence matches getMonitoringInterface: failed, then completed, then active.
+     */
+    getMonitoredAgent(agentId: string): SpawnedAgent | undefined;
     /**
      * Get clickable agent monitoring interface
      */

package/dist/orchestrator/enhanced-multi-agent-orchestrator.js

@@ -302,6 +302,15 @@ export class EnhancedMultiAgentOrchestrator {
             this.spawnAgent(spawn);
         });
     }
+    /**
+     * Lookup one monitored agent without copying every spawn map.
+     * Precedence matches getMonitoringInterface: failed, then completed, then active.
+     */
+    getMonitoredAgent(agentId) {
+        return (this.state.failedAgents.get(agentId) ??
+            this.state.completedAgents.get(agentId) ??
+            this.state.activeAgents.get(agentId));
+    }
     /**
      * Get clickable agent monitoring interface
      */

package/dist/orchestrator/multi-agent-orchestration-coordinator.js

@@ -210,8 +210,7 @@ export class MultiAgentOrchestrationCoordinator {
                     // Wait for completion
                     return new Promise((resolve) => {
                         const checkCompletion = () => {
-                            const monitoringData = this.enhancedOrchestrator.getMonitoringInterface();
-                            const agent = monitoringData[spawnedAgent.id];
+                            const agent = this.enhancedOrchestrator.getMonitoredAgent(spawnedAgent.id);
                             if (agent?.status === "completed") {
                                 resolve({
                                     success: true,

package/dist/orchestrator/orchestrator.js

@@ -470,8 +470,7 @@ export class XrayOrchestrator {
         // Wait for agent completion with monitoring
         return new Promise((resolve, reject) => {
             const checkCompletion = () => {
-                const monitoringData = enhancedMultiAgentOrchestrator.getMonitoringInterface();
-                const agent = monitoringData[spawnedAgent.id];
+                const agent = enhancedMultiAgentOrchestrator.getMonitoredAgent(spawnedAgent.id);
                 if (!agent) {
                     reject(new Error(`Agent ${spawnedAgent.id} not found in monitoring data`));
                     return;

package/dist/processors/implementations/agents-md-validation-processor.d.ts

@@ -51,7 +51,6 @@ export declare class AgentsMdValidationProcessor {
      * Calculate days since date
      */
     private calculateDaysOld;
-    private getPackageVersion;
     private getSectionTemplate;
     appendMissing(): Promise<{
         success: boolean;

package/dist/processors/implementations/agents-md-validation-processor.js

@@ -176,18 +176,7 @@ export class AgentsMdValidationProcessor {
         const now = new Date();
         return Math.ceil((now.getTime() - date.getTime()) / (1000 * 60 * 60 * 24));
     }
-    getPackageVersion() {
-        try {
-            const pkgPath = path.join(this.projectRoot, "package.json");
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-            return pkg.version || "0.0.0";
-        }
-        catch {
-            return "0.0.0";
-        }
-    }
     getSectionTemplate(section) {
-        const version = this.getPackageVersion();
         const now = new Date().toISOString().split("T")[0];
         const templates = {
             "## Available Agents": [

package/dist/processors/implementations/console-log-guard-processor.js

@@ -11,7 +11,13 @@ import { frameworkLogger } from "../../core/framework-logger.js";
 // ---------------------------------------------------------------------------
 // Processor
 // ---------------------------------------------------------------------------
-const CONSOLE_METHODS = ["log", "warn", "error", "info", "debug"];
+const CONSOLE_METHOD_PATTERNS = [
+    { method: "log", pattern: /\bconsole\.log\s*\(/ },
+    { method: "warn", pattern: /\bconsole\.warn\s*\(/ },
+    { method: "error", pattern: /\bconsole\.error\s*\(/ },
+    { method: "info", pattern: /\bconsole\.info\s*\(/ },
+    { method: "debug", pattern: /\bconsole\.debug\s*\(/ },
+];
 const TEST_FILE_PATTERN = /\.(test|spec)\.ts$/;
 export class ConsoleLogGuardProcessor {
     /**
@@ -34,8 +40,7 @@ export class ConsoleLogGuardProcessor {
             const line = lines[i];
             if (!line)
                 continue;
-            for (const method of CONSOLE_METHODS) {
-                const pattern = new RegExp(`\\bconsole\\.${method}\\s*\\(`, "g");
+            for (const { method, pattern } of CONSOLE_METHOD_PATTERNS) {
                 if (pattern.test(line)) {
                     violations.push({
                         line: lineNum,
@@ -58,75 +63,59 @@ export class ConsoleLogGuardProcessor {
      * Preserves line structure so line numbers remain valid.
      */
     stripComments(content) {
-        let result = "";
+        const parts = [];
         let i = 0;
+        let chunkStart = 0;
         const len = content.length;
+        const flush = (end) => {
+            if (end > chunkStart)
+                parts.push(content.slice(chunkStart, end));
+            chunkStart = end;
+        };
         while (i < len) {
-            // Single-line comment: // ... newline
-            if (content[i] === "/" && i + 1 < len && content[i + 1] === "/") {
-                // Skip until end of line
-                while (i < len && content[i] !== "\n") {
-                    i++;
-                }
-                // Keep the newline character to preserve line numbers
-                if (i < len && content[i] === "\n") {
-                    result += "\n";
+            const c = content[i];
+            const next = i + 1 < len ? content[i + 1] : "";
+            // Single-line comment: // ... newline. Newline stays in the next chunk.
+            if (c === "/" && next === "/") {
+                flush(i);
+                while (i < len && content[i] !== "\n")
                     i++;
-                }
+                chunkStart = i;
             }
-            // Multi-line comment: /* ... */
-            else if (content[i] === "/" && i + 1 < len && content[i + 1] === "*") {
-                i += 2; // skip /*
+            // Multi-line comment: /* ... */ — keep newlines so line numbers hold.
+            else if (c === "/" && next === "*") {
+                flush(i);
+                i += 2;
                 while (i < len) {
                     if (content[i] === "*" && i + 1 < len && content[i + 1] === "/") {
-                        i += 2; // skip */
+                        i += 2;
                         break;
                     }
-                    if (content[i] === "\n") {
-                        result += "\n"; // preserve line numbers
-                    }
+                    if (content[i] === "\n")
+                        parts.push("\n");
                     i++;
                 }
+                chunkStart = i;
             }
-            // String literal — skip over to avoid matching // inside strings
-            else if (content[i] === '"' || content[i] === "'" || content[i] === "`") {
-                const quote = content[i];
-                result += content[i];
+            // String literal — walk past it so comment markers inside stay code.
+            else if (c === '"' || c === "'" || c === "`") {
+                const quote = c;
                 i++;
                 while (i < len && content[i] !== quote) {
-                    if (content[i] === "\\" && i + 1 < len) {
-                        result += content[i];
-                        i++;
-                        result += content[i];
+                    if (content[i] === "\\" && i + 1 < len)
+                        i += 2;
+                    else
                         i++;
-                    }
-                    else {
-                        if (content[i] === "\n") {
-                            result += "\n";
-                        }
-                        else {
-                            result += content[i];
-                        }
-                        i++;
-                    }
                 }
-                if (i < len) {
-                    result += content[i]; // closing quote
+                if (i < len)
                     i++;
-                }
             }
-            // Regular character
             else {
-                if (content[i] === "\n") {
-                    result += "\n";
-                }
-                else {
-                    result += content[i];
-                }
                 i++;
             }
         }
-        return result;
+        flush(len);
+        return parts.join("");
     }
 }
 // ---------------------------------------------------------------------------

package/dist/processors/implementations/performance-budget-processor.d.ts

@@ -40,10 +40,5 @@ export declare class PerformanceBudgetProcessor {
      * Does NOT require a full AST – keeps the processor zero-dependency.
      */
     private extractFunctions;
-    /**
-     * Measure the maximum nesting depth by tracking control-flow keywords
-     * (if / for / while / switch / try) inside the function body.
-     */
-    private measureMaxNesting;
 }
 export declare function runPerformanceBudgetCheck(context: PreValidateContext): Promise<ProcessorExecutionResult>;

package/dist/processors/implementations/performance-budget-processor.js

@@ -43,8 +43,9 @@ export class PerformanceBudgetProcessor {
         }
         // --- function-level checks ---
         const funcViolations = this.checkFunctionComplexity(content);
-        for (const v of funcViolations) {
-            violations.push({ ...v, filePath });
+        for (const violation of funcViolations) {
+            violation.filePath = filePath;
+            violations.push(violation);
         }
         return violations;
     }
@@ -67,7 +68,7 @@ export class PerformanceBudgetProcessor {
                 });
             }
             // nesting depth
-            const depth = this.measureMaxNesting(fn.body);
+            const depth = fn.nestingDepth;
             if (depth > this.config.maxNestingDepth) {
                 violations.push({
                     type: "nestingTooDeep",
@@ -123,64 +124,54 @@ export class PerformanceBudgetProcessor {
             const paramCount = params
                 ? params.split(",").filter((p) => p.trim().length > 0).length
                 : 0;
-            // Collect body lines until brace depth returns to 0
+            // Walk the body once: brace span, line count, and nesting share the same lines.
+            // Blank lines are skipped, matching the previous join-then-split of kept lines.
             let depth = 0;
             let started = false;
-            const bodyLines = [];
+            let bodyLineCount = 0;
+            let maxDepth = 0;
+            let currentDepth = 0;
             for (let j = i; j < lines.length; j++) {
                 const l = lines[j];
                 if (!l)
                     continue;
-                for (const ch of l) {
-                    if (ch === "{") {
+                bodyLineCount++;
+                for (let k = 0; k < l.length; k++) {
+                    const ch = l.charCodeAt(k);
+                    if (ch === 123) {
                         depth++;
                         started = true;
                     }
-                    else if (ch === "}") {
+                    else if (ch === 125) {
                         depth--;
                     }
                 }
-                bodyLines.push(l);
+                const trimmed = l.trim();
+                const openingMatches = trimmed.match(/\b(if|for|while|switch|try|catch|else)\b/g);
+                if (openingMatches) {
+                    // 'else' and 'catch' partially close+reopen, so net +0 for those
+                    const netOpen = openingMatches.length -
+                        (trimmed.includes("else") ? 1 : 0) -
+                        (trimmed.includes("catch") ? 1 : 0);
+                    currentDepth += Math.max(0, netOpen);
+                    if (currentDepth > maxDepth)
+                        maxDepth = currentDepth;
+                }
+                const closeBraces = (trimmed.match(/}/g) || []).length;
+                currentDepth = Math.max(0, currentDepth - closeBraces);
                 if (started && depth <= 0)
                     break;
             }
-            const body = bodyLines.join("\n");
             results.push({
                 name,
                 startLine: i + 1,
-                body,
-                bodyLineCount: bodyLines.length,
+                bodyLineCount,
                 paramCount,
+                nestingDepth: maxDepth,
             });
         }
         return results;
     }
-    /**
-     * Measure the maximum nesting depth by tracking control-flow keywords
-     * (if / for / while / switch / try) inside the function body.
-     */
-    measureMaxNesting(body) {
-        let maxDepth = 0;
-        let currentDepth = 0;
-        const lines = body.split("\n");
-        for (const line of lines) {
-            const trimmed = line.trim();
-            // Count opening structures that increase nesting
-            const openingMatches = trimmed.match(/\b(if|for|while|switch|try|catch|else)\b/g);
-            if (openingMatches) {
-                // 'else' and 'catch' partially close+reopen, so net +0 for those
-                const netOpen = openingMatches.length -
-                    (trimmed.includes("else") ? 1 : 0) -
-                    (trimmed.includes("catch") ? 1 : 0);
-                currentDepth += Math.max(0, netOpen);
-                maxDepth = Math.max(maxDepth, currentDepth);
-            }
-            // Simple heuristic: decrease depth when line closes braces
-            const closeBraces = (trimmed.match(/}/g) || []).length;
-            currentDepth = Math.max(0, currentDepth - closeBraces);
-        }
-        return maxDepth;
-    }
 }
 // ---------------------------------------------------------------------------
 // Standalone runner for processor-manager integration

package/dist/processors/implementations/storytelling-trigger-processor.d.ts

@@ -17,6 +17,11 @@ export declare class StorytellingTriggerProcessor extends PostProcessor {
     private extractDecisions;
     private synthesizeInferences;
     private getCommitsBetween;
+    /**
+     * One `git log --name-only` for the range. Same paths as `git diff --name-only HASH~1 HASH`
+     * for non-merge commits. Null means the caller should fall back per commit.
+     */
+    private fileNamesByCommit;
     private getRecentCommits;
     private summarizeCommits;
     private getLastTag;

package/dist/processors/implementations/storytelling-trigger-processor.js

@@ -156,8 +156,13 @@ export class StorytellingTriggerProcessor extends PostProcessor {
         if (diff.uniqueDirs.length > 0) {
             lines.push("## Areas Touched");
             lines.push("");
+            const touched = diff.filesAdded.concat(diff.filesModified);
             for (const dir of diff.uniqueDirs.slice(0, 15)) {
-                const count = [...diff.filesAdded, ...diff.filesModified].filter(f => f.startsWith(dir)).length;
+                let count = 0;
+                for (const fileName of touched) {
+                    if (fileName.startsWith(dir))
+                        count++;
+                }
                 lines.push(`- \`${dir}\` (${count} files)`);
             }
             lines.push("");
@@ -370,12 +375,16 @@ export class StorytellingTriggerProcessor extends PostProcessor {
         }
         return inferences;
     }
-    getCommitsBetween(from, to) {
+    getCommitsBetween(from, to, limit) {
         try {
-            const log = this.git(`git log ${from}..${to} --format="%H||%s||%an||%aI" --shortstat --no-merges`);
+            // Newest-first, so -n matches slice(0, limit). %x1e starts every commit, including
+            // one with no shortstat — a blank-line split would glue that header to the next.
+            const limitArg = typeof limit === "number" && limit > 0 ? `-n ${Math.floor(limit)} ` : "";
+            const log = this.git(`git log ${limitArg}${from}..${to} --format="%x1e%H||%s||%an||%aI" --shortstat --no-merges`);
             if (!log)
                 return [];
-            const commitBlocks = log.split(/\n{2,}/).filter((b) => b.trim().length > 0 && b.includes("||"));
+            const namesByHash = this.fileNamesByCommit(from, to, limit);
+            const commitBlocks = log.split("\x1e").filter((b) => b.includes("||"));
             return commitBlocks.map((block) => {
                 const lines = block.trim().split("\n");
                 const headerLine = lines.find((l) => l.includes("||")) || "";
@@ -384,15 +393,21 @@ export class StorytellingTriggerProcessor extends PostProcessor {
                 const filesChanged = parseInt(statsLine.match(/(\d+) files? changed/)?.[1] || "0", 10);
                 const insertions = parseInt(statsLine.match(/(\d+) insertion/)?.[1] || "0", 10);
                 const deletions = parseInt(statsLine.match(/(\d+) deletion/)?.[1] || "0", 10);
+                const fullHash = (hash || "").trim();
                 let fileNames = [];
-                try {
-                    const shortHash = (hash || "").slice(0, 7);
-                    const namesOutput = this.git(`git diff --name-only ${shortHash}~1 ${shortHash} 2>/dev/null`);
-                    fileNames = namesOutput ? namesOutput.split("\n").filter(Boolean) : [];
+                if (namesByHash?.has(fullHash)) {
+                    fileNames = namesByHash.get(fullHash) ?? [];
+                }
+                else {
+                    try {
+                        const shortHash = fullHash.slice(0, 7);
+                        const namesOutput = this.git(`git diff --name-only ${shortHash}~1 ${shortHash} 2>/dev/null`);
+                        fileNames = namesOutput ? namesOutput.split("\n").filter(Boolean) : [];
+                    }
+                    catch { /* empty */ }
                 }
-                catch { /* empty */ }
                 return {
-                    hash: (hash || "").slice(0, 7),
+                    hash: fullHash.slice(0, 7),
                     message: message || "",
                     author: author || "",
                     date: date || "",
@@ -407,13 +422,44 @@ export class StorytellingTriggerProcessor extends PostProcessor {
             return [];
         }
     }
+    /**
+     * One `git log --name-only` for the range. Same paths as `git diff --name-only HASH~1 HASH`
+     * for non-merge commits. Null means the caller should fall back per commit.
+     */
+    fileNamesByCommit(from, to, limit) {
+        const limitArg = typeof limit === "number" && limit > 0 ? `-n ${Math.floor(limit)} ` : "";
+        const out = this.git(`git log ${limitArg}${from}..${to} --no-merges --name-only --pretty=format:%x1e%H`);
+        if (!out)
+            return null;
+        const names = new Map();
+        for (const chunk of out.split("\x1e")) {
+            if (chunk.trim().length === 0)
+                continue;
+            let hash = "";
+            const files = [];
+            for (const line of chunk.split("\n")) {
+                if (!hash) {
+                    if (/^[0-9a-f]{40}$/.test(line))
+                        hash = line;
+                    continue;
+                }
+                if (line.length > 0)
+                    files.push(line);
+            }
+            if (hash)
+                names.set(hash, files);
+        }
+        return names;
+    }
     getRecentCommits(count) {
         try {
+            if (!(count > 0))
+                return [];
             const hash = this.git("git rev-list --max-parents=0 HEAD");
             if (!hash)
                 return [];
             const firstCommit = hash.split("\n")[0].trim();
-            return this.getCommitsBetween(firstCommit, "HEAD").slice(0, count);
+            return this.getCommitsBetween(firstCommit, "HEAD", count);
         }
         catch {
             return [];
@@ -453,11 +499,18 @@ export class StorytellingTriggerProcessor extends PostProcessor {
                 filesModified.push(file);
             }
         }
-        const uniqueDirs = [...new Set([...filesAdded, ...filesModified, ...filesDeleted]
-                .map((f) => {
-                const parts = f.split("/");
-                return parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
-            }))].sort();
+        const dirSet = new Set();
+        const addDir = (fileName) => {
+            const slash = fileName.lastIndexOf("/");
+            dirSet.add(slash >= 0 ? fileName.slice(0, slash) : ".");
+        };
+        for (const fileName of filesAdded)
+            addDir(fileName);
+        for (const fileName of filesModified)
+            addDir(fileName);
+        for (const fileName of filesDeleted)
+            addDir(fileName);
+        const uniqueDirs = [...dirSet].sort();
         return {
             totalCommits: commits.length,
             totalFilesChanged: allFiles.size,

package/dist/processors/implementations/test-auto-creation-processor.js

@@ -28,55 +28,58 @@ function findRecentlyModifiedTsFile(dir, maxAgeSeconds = 60) {
         return cached.file;
     }
     try {
-        // Recursive walk to find all .ts files
-        const files = [];
+        // One stat per source file. Dirent tells files from directories; mtime is kept
+        // on that stat so the walk does not stat the same path again.
+        // Holder avoids TS narrowing the binding to null across the closure.
+        const mostRecent = { path: null, mtime: 0 };
+        const shouldWalk = (name) => !name.startsWith(".") && name !== "node_modules" && name !== "dist";
+        const isTsSource = (name) => name.endsWith(".ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
+        const consider = (fullPath, mtimeMs) => {
+            const relPath = path.relative(dir, fullPath);
+            if (mostRecent.path === null || mtimeMs > mostRecent.mtime) {
+                mostRecent.path = relPath;
+                mostRecent.mtime = mtimeMs;
+            }
+        };
         function walkSync(dirPath) {
+            let items;
             try {
-                const items = fs.readdirSync(dirPath);
-                for (const item of items) {
-                    const fullPath = path.join(dirPath, item);
-                    try {
+                items = fs.readdirSync(dirPath, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const item of items) {
+                const name = item.name;
+                const fullPath = path.join(dirPath, name);
+                try {
+                    // stat follows links, so a symlink to a directory is still walked.
+                    if (item.isSymbolicLink()) {
                         const stat = fs.statSync(fullPath);
                         if (stat.isDirectory()) {
-                            // Skip node_modules, dist, etc.
-                            if (!item.startsWith(".") &&
-                                item !== "node_modules" &&
-                                item !== "dist") {
+                            if (shouldWalk(name))
                                 walkSync(fullPath);
-                            }
                         }
-                        else if (item.endsWith(".ts") &&
-                            !item.endsWith(".test.ts") &&
-                            !item.endsWith(".spec.ts")) {
-                            files.push(fullPath);
+                        else if (isTsSource(name)) {
+                            consider(fullPath, stat.mtimeMs);
                         }
+                        continue;
                     }
-                    catch {
-                        // Skip files we can't stat
+                    if (item.isDirectory()) {
+                        if (shouldWalk(name))
+                            walkSync(fullPath);
+                    }
+                    else if (isTsSource(name)) {
+                        consider(fullPath, fs.statSync(fullPath).mtimeMs);
                     }
                 }
-            }
-            catch {
-                // Skip directories we can't read
-            }
-        }
-        walkSync(dir);
-        // Find most recently modified
-        let mostRecent = null;
-        for (const filePath of files) {
-            try {
-                const stats = fs.statSync(filePath);
-                // Get relative path
-                const relPath = path.relative(dir, filePath);
-                if (!mostRecent || stats.mtimeMs > mostRecent.mtime) {
-                    mostRecent = { path: relPath, mtime: stats.mtimeMs };
+                catch {
+                    // Skip files we can't stat
                 }
             }
-            catch {
-                // Skip files we can't stat
-            }
         }
-        const result = mostRecent?.path || null;
+        walkSync(dir);
+        const result = mostRecent.path;
         // Cache the result
         fileScanCache.set(cacheKey, {
             file: result,

package/dist/reporting/framework-reporting-system.d.ts

@@ -8,6 +8,9 @@ export declare class FrameworkReportingSystem {
     getRealtimeStatus(): Promise<RealtimeStatus>;
     createCustomReport(template: CustomReportTemplate): string;
     private generateReportId;
+    private activityLogFile;
+    private currentLogStamp;
+    private memoryLogStamp;
     private getCachedReport;
     private isCacheValid;
     private cacheReport;