@juspay/yama 2.3.0 → 2.4.1

package/dist/v2/exploration/ContextExplorerService.js

@@ -0,0 +1,451 @@
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { NeuroLink } from "@juspay/neurolink";
+import { MCPServerManager } from "../core/MCPServerManager.js";
+import { KnowledgeBaseManager } from "../learning/KnowledgeBaseManager.js";
+import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
+import { ExplorerPromptBuilder } from "./ExplorerPromptBuilder.js";
+import { RulesContextLoader } from "./RulesContextLoader.js";
+export class ContextExplorerService {
+    config;
+    sessionManager;
+    memoryManager;
+    projectRoot;
+    promptBuilder = new ExplorerPromptBuilder();
+    rulesContextLoader;
+    mcpManager = new MCPServerManager();
+    neurolink;
+    prMcpInitialized = false;
+    localMcpInitialized = false;
+    constructor(config, sessionManager, memoryManager, projectRoot = process.cwd()) {
+        this.config = config;
+        this.sessionManager = sessionManager;
+        this.memoryManager = memoryManager;
+        this.projectRoot = projectRoot;
+        this.rulesContextLoader = new RulesContextLoader(config.memoryBank, config.projectStandards, projectRoot);
+        this.neurolink = this.initializeNeurolink();
+    }
+    async initialize(mode) {
+        if (mode === "pr" && !this.prMcpInitialized) {
+            await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
+            this.prMcpInitialized = true;
+            return;
+        }
+        if (mode === "local" && !this.localMcpInitialized) {
+            await this.mcpManager.setupLocalGitMCPServer(this.neurolink);
+            this.localMcpInitialized = true;
+        }
+    }
+    async explore(input, runtimeContext) {
+        await this.initialize(runtimeContext.mode);
+        const normalizedInput = this.normalizeInput(input);
+        const cacheKey = this.buildCacheKey(normalizedInput, runtimeContext);
+        if (this.config.ai.explore.cacheResults) {
+            const cached = this.sessionManager.findExploration(runtimeContext.sessionId, cacheKey);
+            if (cached) {
+                return { result: cached, cached: true };
+            }
+        }
+        const [projectRules, projectStandards, knowledgeBase, repositoryMemory] = await Promise.all([
+            this.rulesContextLoader.load(),
+            this.loadProjectStandards(),
+            this.loadKnowledgeBase(),
+            this.loadRepositoryMemory(runtimeContext),
+        ]);
+        const prompt = this.promptBuilder.buildPrompt(normalizedInput, runtimeContext, {
+            projectRules,
+            projectStandards,
+            knowledgeBase,
+            repositoryMemory,
+        });
+        this.neurolink.setToolContext(runtimeContext);
+        console.log(`   🔎 Explore: ${normalizedInput.task}`);
+        const researchResponse = await this.neurolink.generate({
+            input: { text: prompt },
+            provider: this.config.ai.explore.provider || this.config.ai.provider,
+            model: this.config.ai.explore.model || this.config.ai.model,
+            temperature: this.config.ai.explore.temperature ?? this.config.ai.temperature,
+            maxTokens: this.config.ai.explore.maxTokens || this.config.ai.maxTokens,
+            timeout: this.config.ai.explore.timeout || this.config.ai.timeout,
+            skipToolPromptInjection: true,
+            ...this.getToolFilteringOptions(runtimeContext.mode),
+            context: {
+                sessionId: runtimeContext.sessionId,
+                userId: `${runtimeContext.workspace}-${runtimeContext.repository}`.toLowerCase(),
+                operation: "explore-context-research",
+                metadata: runtimeContext.metadata || {},
+            },
+            memory: { enabled: false },
+            enableAnalytics: this.config.ai.enableAnalytics,
+            enableEvaluation: false,
+        });
+        const extractionPrompt = this.buildExtractionPrompt(normalizedInput.task, researchResponse);
+        const extractionResponse = await this.neurolink.generate({
+            input: { text: extractionPrompt },
+            provider: this.config.ai.explore.provider || this.config.ai.provider,
+            model: this.config.ai.explore.model || this.config.ai.model,
+            temperature: 0.1,
+            maxTokens: Math.min(this.config.ai.explore.maxTokens || this.config.ai.maxTokens, 12_000),
+            timeout: "2m",
+            disableTools: true,
+            context: {
+                sessionId: runtimeContext.sessionId,
+                userId: `${runtimeContext.workspace}-${runtimeContext.repository}`.toLowerCase(),
+                operation: "explore-context-extraction",
+                metadata: runtimeContext.metadata || {},
+            },
+            memory: { enabled: false },
+            enableAnalytics: this.config.ai.enableAnalytics,
+            enableEvaluation: false,
+        });
+        const result = this.normalizeResult(normalizedInput.task, extractionResponse?.content);
+        if (this.shouldCacheResult(result)) {
+            this.sessionManager.recordExploration(runtimeContext.sessionId, cacheKey, normalizedInput.task, normalizedInput.focus || [], result);
+        }
+        return { result, cached: false };
+    }
+    normalizeInput(input) {
+        const task = typeof input.task === "string" ? input.task.trim() : "";
+        if (!task) {
+            throw new Error("explore_context requires a non-empty task");
+        }
+        const focus = Array.isArray(input.focus)
+            ? input.focus
+                .filter((value) => typeof value === "string")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : undefined;
+        return {
+            task,
+            focus,
+        };
+    }
+    buildCacheKey(input, runtimeContext) {
+        return JSON.stringify({
+            mode: runtimeContext.mode,
+            workspace: runtimeContext.workspace,
+            repository: runtimeContext.repository,
+            pullRequestId: runtimeContext.pullRequestId || null,
+            branch: runtimeContext.branch || null,
+            task: input.task.toLowerCase(),
+            focus: (input.focus || []).map((item) => item.toLowerCase()),
+        });
+    }
+    getToolFilteringOptions(mode) {
+        try {
+            const externalTools = this.neurolink.getExternalMCPTools?.();
+            if (!Array.isArray(externalTools)) {
+                return {};
+            }
+            const excludeTools = externalTools
+                .map((tool) => tool?.name)
+                .filter((name) => typeof name === "string")
+                .filter((name) => this.shouldExcludeTool(mode, name));
+            return excludeTools.length > 0 ? { excludeTools } : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    shouldExcludeTool(mode, toolName) {
+        const normalized = this.normalizeToolName(toolName);
+        if (/^(add_comment|set_pr_approval|set_review_status|approve_pull_request|unapprove_pull_request|request_changes|remove_requested_changes|update_pull_request|merge_pull_request|delete_branch)$/i.test(normalized)) {
+            return true;
+        }
+        if (mode === "local") {
+            return /^git_(commit|push|add|checkout|create_branch|merge|rebase|cherry_pick|reset|revert|tag|rm|clean|stash|apply)\b/i.test(normalized);
+        }
+        return false;
+    }
+    normalizeToolName(name) {
+        return name.split(/[.:/]/).pop() || name;
+    }
+    normalizeResult(task, content) {
+        const rawText = typeof content === "string" ? content : JSON.stringify(content || {});
+        const parsed = this.extractJsonPayload(rawText);
+        const findings = this.normalizeFindings(parsed?.findings);
+        const evidence = this.normalizeEvidence(parsed?.evidence);
+        const openQuestions = Array.isArray(parsed?.openQuestions)
+            ? parsed.openQuestions
+                .filter((value) => typeof value === "string")
+                .map((value) => value.trim())
+                .filter(Boolean)
+            : [];
+        return {
+            task,
+            summary: (typeof parsed?.summary === "string" && parsed.summary.trim()) ||
+                "Explore returned unstructured output and could not produce verified findings.",
+            findings,
+            evidence,
+            openQuestions: openQuestions.length > 0
+                ? openQuestions
+                : parsed
+                    ? []
+                    : [
+                        "Explore did not return structured JSON. Retry with a narrower task or inspect the raw investigation path.",
+                    ],
+            recommendedNextStep: parsed
+                ? this.normalizeNextStep(parsed?.recommendedNextStep)
+                : "explore_more",
+            completedAt: new Date().toISOString(),
+        };
+    }
+    buildExtractionPrompt(task, researchResponse) {
+        const researchContent = this.truncateForExtraction(typeof researchResponse?.content === "string"
+            ? researchResponse.content
+            : JSON.stringify(researchResponse?.content || {}), 16_000);
+        const toolCalls = Array.isArray(researchResponse?.toolCalls)
+            ? researchResponse.toolCalls.map((call) => ({
+                toolName: call?.toolName || call?.name || call?.tool || "unknown_tool",
+                parameters: call?.parameters || call?.args || {},
+            }))
+            : [];
+        const toolResults = Array.isArray(researchResponse?.toolResults)
+            ? researchResponse.toolResults.map((result) => ({
+                toolName: result?.toolName || "unknown_tool",
+                error: result?.error,
+                result: this.truncateForExtraction(JSON.stringify(result?.result || result?.content || result || {}), 8_000),
+            }))
+            : [];
+        return `
+You are converting an Explore research run into strict JSON.
+
+Original task:
+${task}
+
+Research response text:
+${researchContent || "(empty)"}
+
+Tool calls:
+${JSON.stringify(toolCalls, null, 2)}
+
+Tool results:
+${JSON.stringify(toolResults, null, 2)}
+
+Return ONLY valid JSON with this exact shape:
+{
+  "summary": "string",
+  "findings": [
+    {
+      "claim": "string",
+      "confidence": "high|medium|low"
+    }
+  ],
+  "evidence": [
+    {
+      "sourceType": "file|commit|diff|jira|memory|rules|kb",
+      "ref": "string",
+      "snippet": "string",
+      "reason": "string"
+    }
+  ],
+  "openQuestions": ["string"],
+  "recommendedNextStep": "continue_review|explore_more|avoid_commenting"
+}
+
+Rules:
+- Use only information present in the research response and tool results.
+- If evidence is insufficient, keep findings empty and set recommendedNextStep to "explore_more".
+- Prefer precise file paths, commit SHAs, or ticket IDs in evidence.ref.
+- Do not include markdown fences or prose outside JSON.
+    `.trim();
+    }
+    truncateForExtraction(value, maxChars) {
+        if (value.length <= maxChars) {
+            return value;
+        }
+        return `${value.slice(0, maxChars)}\n... [truncated]`;
+    }
+    shouldCacheResult(result) {
+        if (result.findings.length > 0 || result.evidence.length > 0) {
+            return true;
+        }
+        return (result.summary !==
+            "Explore returned unstructured output and could not produce verified findings." &&
+            result.openQuestions.length === 0);
+    }
+    normalizeFindings(input) {
+        if (!Array.isArray(input)) {
+            return [];
+        }
+        return input
+            .map((entry) => {
+            const value = (entry || {});
+            const claim = typeof value.claim === "string" ? value.claim.trim() : "";
+            if (!claim) {
+                return null;
+            }
+            return {
+                claim,
+                confidence: this.normalizeConfidence(value.confidence),
+            };
+        })
+            .filter((entry) => entry !== null);
+    }
+    normalizeEvidence(input) {
+        if (!Array.isArray(input)) {
+            return [];
+        }
+        return input
+            .map((entry) => {
+            const value = (entry || {});
+            const sourceType = this.normalizeSourceType(value.sourceType);
+            const ref = typeof value.ref === "string" ? value.ref.trim() : "";
+            const reason = typeof value.reason === "string" ? value.reason.trim() : "";
+            if (!ref || !reason) {
+                return null;
+            }
+            const result = {
+                sourceType,
+                ref,
+                reason,
+            };
+            if (typeof value.snippet === "string" && value.snippet.trim()) {
+                result.snippet = value.snippet.trim();
+            }
+            return result;
+        })
+            .filter((entry) => entry !== null);
+    }
+    normalizeConfidence(value) {
+        if (typeof value !== "string") {
+            return "medium";
+        }
+        const normalized = value.toLowerCase();
+        return normalized === "high" ||
+            normalized === "medium" ||
+            normalized === "low"
+            ? normalized
+            : "medium";
+    }
+    normalizeSourceType(value) {
+        if (typeof value !== "string") {
+            return "file";
+        }
+        const normalized = value.toLowerCase();
+        if (normalized === "file" ||
+            normalized === "commit" ||
+            normalized === "diff" ||
+            normalized === "jira" ||
+            normalized === "memory" ||
+            normalized === "rules" ||
+            normalized === "kb") {
+            return normalized;
+        }
+        return "file";
+    }
+    normalizeNextStep(value) {
+        if (typeof value !== "string") {
+            return "continue_review";
+        }
+        const normalized = value.toLowerCase();
+        if (normalized === "continue_review" ||
+            normalized === "explore_more" ||
+            normalized === "avoid_commenting") {
+            return normalized;
+        }
+        return "continue_review";
+    }
+    extractJsonPayload(content) {
+        if (!content || typeof content !== "string") {
+            return null;
+        }
+        const trimmed = content.trim();
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Fall through to extraction strategies
+        }
+        const fenceOpen = trimmed.toLowerCase().indexOf("```json");
+        if (fenceOpen !== -1) {
+            let contentStart = fenceOpen + 7;
+            while (contentStart < trimmed.length &&
+                (trimmed[contentStart] === " " ||
+                    trimmed[contentStart] === "\n" ||
+                    trimmed[contentStart] === "\r")) {
+                contentStart++;
+            }
+            const fenceClose = trimmed.indexOf("```", contentStart);
+            if (fenceClose !== -1) {
+                try {
+                    return JSON.parse(trimmed.slice(contentStart, fenceClose).trim());
+                }
+                catch {
+                    return null;
+                }
+            }
+        }
+        const start = trimmed.indexOf("{");
+        const end = trimmed.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            try {
+                return JSON.parse(trimmed.slice(start, end + 1));
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    async loadProjectStandards() {
+        if (!this.config.projectStandards?.customPromptsPath) {
+            return null;
+        }
+        const promptDir = join(this.projectRoot, this.config.projectStandards.customPromptsPath);
+        const promptFiles = [
+            "review-standards.md",
+            "security-guidelines.md",
+            "coding-conventions.md",
+        ];
+        const sections = [];
+        for (const file of promptFiles) {
+            const absolutePath = join(promptDir, file);
+            if (!existsSync(absolutePath)) {
+                continue;
+            }
+            try {
+                const content = await readFile(absolutePath, "utf-8");
+                sections.push(`## ${file}\n\n${content}`);
+            }
+            catch {
+                continue;
+            }
+        }
+        return sections.length > 0 ? sections.join("\n\n---\n\n") : null;
+    }
+    async loadKnowledgeBase() {
+        if (!this.config.knowledgeBase?.enabled) {
+            return null;
+        }
+        try {
+            return await new KnowledgeBaseManager(this.config.knowledgeBase, this.projectRoot).getForPrompt();
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadRepositoryMemory(runtimeContext) {
+        if (!this.memoryManager) {
+            return null;
+        }
+        return this.memoryManager.readRepositoryMemory(runtimeContext.workspace, runtimeContext.repository);
+    }
+    initializeNeurolink() {
+        const observabilityConfig = buildObservabilityConfigFromEnv();
+        const neurolinkConfig = {
+            conversationMemory: {
+                enabled: false,
+            },
+        };
+        if (observabilityConfig) {
+            if (!validateObservabilityConfig(observabilityConfig)) {
+                throw new Error("Invalid observability configuration");
+            }
+            neurolinkConfig.observability = observabilityConfig;
+        }
+        return new NeuroLink(neurolinkConfig);
+    }
+}
+//# sourceMappingURL=ContextExplorerService.js.map

package/dist/v2/exploration/ExplorerPromptBuilder.d.ts

@@ -0,0 +1,5 @@
+import { ExplorerSupportingContext, ExploreContextInput, ExploreRuntimeContext } from "./types.js";
+export declare class ExplorerPromptBuilder {
+    buildPrompt(input: ExploreContextInput, runtimeContext: ExploreRuntimeContext, supportingContext: ExplorerSupportingContext): string;
+}
+//# sourceMappingURL=ExplorerPromptBuilder.d.ts.map

package/dist/v2/exploration/ExplorerPromptBuilder.js

@@ -0,0 +1,67 @@
+export class ExplorerPromptBuilder {
+    buildPrompt(input, runtimeContext, supportingContext) {
+        const focus = input.focus && input.focus.length > 0
+            ? input.focus
+            : ["No explicit focus provided"];
+        const contextSections = [];
+        if (supportingContext.projectRules) {
+            contextSections.push(`<project-rules>\n${supportingContext.projectRules}\n</project-rules>`);
+        }
+        if (supportingContext.projectStandards) {
+            contextSections.push(`<project-standards>\n${supportingContext.projectStandards}\n</project-standards>`);
+        }
+        if (supportingContext.knowledgeBase) {
+            contextSections.push(`<knowledge-base>\n${supportingContext.knowledgeBase}\n</knowledge-base>`);
+        }
+        if (supportingContext.repositoryMemory) {
+            contextSections.push(`<repository-memory>\n${supportingContext.repositoryMemory}\n</repository-memory>`);
+        }
+        return `
+You are Explore, a generic research worker for Yama.
+Your job is to investigate the assigned task using available tools and return only the required JSON object.
+
+Rules:
+1. You are not the reviewer. Do not approve, block, comment on the PR, or mutate repository state.
+2. Use tools as many times as needed until you can answer the task with evidence.
+3. Prefer the smallest sufficient evidence. Do not dump raw tool output.
+4. If you are uncertain, say so explicitly in findings or openQuestions.
+5. Return valid JSON only. No markdown fences or commentary outside JSON.
+
+Research task:
+- Task: ${input.task}
+- Review mode: ${runtimeContext.mode}
+- Workspace: ${runtimeContext.workspace}
+- Repository: ${runtimeContext.repository}
+- Pull request: ${runtimeContext.pullRequestId ?? "N/A"}
+- Branch: ${runtimeContext.branch || "N/A"}
+
+Focus areas:
+${focus.map((item) => `- ${item}`).join("\n")}
+
+${contextSections.join("\n\n")}
+
+Return this exact JSON shape:
+{
+  "task": "string",
+  "summary": "string",
+  "findings": [
+    {
+      "claim": "string",
+      "confidence": "high|medium|low"
+    }
+  ],
+  "evidence": [
+    {
+      "sourceType": "file|commit|diff|jira|memory|rules|kb",
+      "ref": "string",
+      "snippet": "string",
+      "reason": "string"
+    }
+  ],
+  "openQuestions": ["string"],
+  "recommendedNextStep": "continue_review|explore_more|avoid_commenting"
+}
+    `.trim();
+    }
+}
+//# sourceMappingURL=ExplorerPromptBuilder.js.map

package/dist/v2/exploration/RulesContextLoader.d.ts

@@ -0,0 +1,12 @@
+import { MemoryBankConfig, ProjectStandardsConfig } from "../types/config.types.js";
+export declare class RulesContextLoader {
+    private readonly memoryBank;
+    private readonly projectStandards?;
+    private readonly projectRoot;
+    constructor(memoryBank: MemoryBankConfig, projectStandards?: ProjectStandardsConfig | undefined, projectRoot?: string);
+    load(): Promise<string | null>;
+    private resolveMemoryBankDir;
+    private tryReadDirectory;
+    private tryReadFile;
+}
+//# sourceMappingURL=RulesContextLoader.d.ts.map

package/dist/v2/exploration/RulesContextLoader.js

@@ -0,0 +1,106 @@
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+const ROOT_RULE_FILES = ["CLAUDE.md", ".clinerules", "CONTRIBUTING.md"];
+const CONTEXT_EXTENSIONS = new Set([".md", ".txt", ".yml", ".yaml"]);
+export class RulesContextLoader {
+    memoryBank;
+    projectStandards;
+    projectRoot;
+    constructor(memoryBank, projectStandards, projectRoot = process.cwd()) {
+        this.memoryBank = memoryBank;
+        this.projectStandards = projectStandards;
+        this.projectRoot = projectRoot;
+    }
+    async load() {
+        const sections = [];
+        for (const file of ROOT_RULE_FILES) {
+            const absolutePath = resolve(this.projectRoot, file);
+            const content = await this.tryReadFile(absolutePath);
+            if (content) {
+                sections.push(`## ${file}\n\n${content}`);
+            }
+        }
+        const memoryBankDir = this.resolveMemoryBankDir();
+        if (memoryBankDir) {
+            const standardFiles = this.memoryBank.standardFiles || [];
+            for (const file of standardFiles) {
+                const absolutePath = join(memoryBankDir, file);
+                const content = await this.tryReadFile(absolutePath);
+                if (content) {
+                    sections.push(`## memory-bank/${file}\n\n${content}`);
+                }
+            }
+            const directoryEntries = await this.tryReadDirectory(memoryBankDir);
+            for (const entry of directoryEntries) {
+                if (standardFiles.includes(entry)) {
+                    continue;
+                }
+                const extension = entry.slice(entry.lastIndexOf("."));
+                if (!CONTEXT_EXTENSIONS.has(extension)) {
+                    continue;
+                }
+                const absolutePath = join(memoryBankDir, entry);
+                const content = await this.tryReadFile(absolutePath);
+                if (content) {
+                    sections.push(`## memory-bank/${entry}\n\n${content}`);
+                }
+            }
+        }
+        if (this.projectStandards?.customPromptsPath) {
+            const promptDir = resolve(this.projectRoot, this.projectStandards.customPromptsPath);
+            const promptFiles = [
+                "review-standards.md",
+                "security-guidelines.md",
+                "coding-conventions.md",
+            ];
+            for (const file of promptFiles) {
+                const content = await this.tryReadFile(join(promptDir, file));
+                if (content) {
+                    sections.push(`## prompts/${file}\n\n${content}`);
+                }
+            }
+        }
+        if (sections.length === 0) {
+            return null;
+        }
+        return sections.join("\n\n---\n\n");
+    }
+    resolveMemoryBankDir() {
+        if (!this.memoryBank.enabled) {
+            return null;
+        }
+        const candidates = [this.memoryBank.path, ...this.memoryBank.fallbackPaths];
+        for (const candidate of candidates) {
+            const absolutePath = resolve(this.projectRoot, candidate);
+            if (existsSync(absolutePath)) {
+                return absolutePath;
+            }
+        }
+        return null;
+    }
+    async tryReadDirectory(path) {
+        try {
+            const entries = await readdir(path, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isFile())
+                .map((entry) => entry.name)
+                .sort((left, right) => left.localeCompare(right));
+        }
+        catch {
+            return [];
+        }
+    }
+    async tryReadFile(path) {
+        if (!existsSync(path)) {
+            return null;
+        }
+        try {
+            return await readFile(path, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=RulesContextLoader.js.map

package/dist/v2/exploration/types.d.ts

@@ -0,0 +1,26 @@
+import { ExplorationResult } from "../types/v2.types.js";
+export interface ExploreContextInput {
+    task: string;
+    focus?: string[];
+}
+export interface ExploreRuntimeContext {
+    sessionId: string;
+    mode: "pr" | "local";
+    workspace: string;
+    repository: string;
+    pullRequestId?: number;
+    branch?: string;
+    dryRun?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ExplorerSupportingContext {
+    projectRules: string | null;
+    projectStandards: string | null;
+    knowledgeBase: string | null;
+    repositoryMemory: string | null;
+}
+export interface ExploreExecutionResult {
+    result: ExplorationResult;
+    cached: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/v2/exploration/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/v2/memory/MemoryManager.d.ts

@@ -40,6 +40,14 @@ export declare class MemoryManager {
      * This value is passed as `context.userId` in generate() calls.
      */
     static buildOwnerId(workspace: string, repository: string): string;
+    /**
+     * Read persisted condensed memory for a repository owner ID.
+     */
+    readMemory(ownerId: string): Promise<string | null>;
+    /**
+     * Read persisted condensed memory for a workspace/repository pair.
+     */
+    readRepositoryMemory(workspace: string, repository: string): Promise<string | null>;
     /**
      * Commit memory files to the repository if autoCommit is enabled.
      *