byterover-cli 3.0.0 → 3.1.0

package/dist/agent/infra/memory/memory-deduplicator.js

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto';
+import { streamToText } from '../llm/stream-to-text.js';
+const SYSTEM_PROMPT = `You are a memory deduplication assistant. Given a new draft memory and a list of existing memories, decide one of:
+- CREATE: the draft is new and should be stored as-is
+- MERGE: the draft overlaps with an existing memory; provide merged content
+- SKIP: the draft is already covered by an existing memory
+
+Respond with ONLY a JSON object:
+{"action": "CREATE"}
+{"action": "MERGE", "targetId": "<id>", "mergedContent": "<combined content>"}
+{"action": "SKIP"}`;
+const DEDUPLICATION_CONCURRENCY = 4;
+/**
+ * LLM-based deduplicator for agent-extracted memories.
+ *
+ * For each draft, checks against existing memories via an LLM call.
+ * DECISIONS category drafts always result in CREATE (immutable log).
+ */
+export class MemoryDeduplicator {
+    generator;
+    constructor(generator) {
+        this.generator = generator;
+    }
+    /**
+     * Deduplicate a list of draft memories against existing stored memories.
+     *
+     * @param drafts - Draft memories to check
+     * @param existing - Existing memories to compare against
+     * @returns Deduplication action for each draft
+     */
+    async deduplicate(drafts, existing) {
+        if (existing.length === 0) {
+            return drafts.map((memory) => ({ action: 'CREATE', memory }));
+        }
+        const actions = Array.from({ length: drafts.length });
+        const concurrency = Math.min(DEDUPLICATION_CONCURRENCY, drafts.length);
+        const worker = async (workerIndex) => {
+            for (let draftIndex = workerIndex; draftIndex < drafts.length; draftIndex += concurrency) {
+                const draft = drafts[draftIndex];
+                if (draft.category === 'DECISIONS') {
+                    actions[draftIndex] = { action: 'CREATE', memory: draft };
+                    continue;
+                }
+                // eslint-disable-next-line no-await-in-loop
+                actions[draftIndex] = await this.deduplicateSingle(draft, existing);
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, async (_, workerIndex) => worker(workerIndex)));
+        return actions;
+    }
+    async deduplicateSingle(draft, existing) {
+        const existingSummary = JSON.stringify(existing.map((m) => ({ content: m.content.slice(0, 300), id: m.id })));
+        const prompt = `## Draft Memory (category: ${draft.category})
+${draft.content}
+
+## Existing Memories (JSON)
+${existingSummary}
+
+Decide: CREATE, MERGE (with targetId and mergedContent), or SKIP.`;
+        try {
+            // Use streaming — ChatGPT OAuth Codex endpoint requires stream: true
+            const responseText = await streamToText(this.generator, {
+                config: { maxTokens: 300, temperature: 0 },
+                contents: [{ content: prompt, role: 'user' }],
+                model: 'default',
+                systemPrompt: SYSTEM_PROMPT,
+                taskId: randomUUID(),
+            });
+            // Strip markdown code fences — some providers wrap JSON in ```json ... ```
+            const jsonText = responseText.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+            const parsed = JSON.parse(jsonText);
+            const targetExists = parsed.targetId ? existing.some((memory) => memory.id === parsed.targetId) : false;
+            if (parsed.action === 'MERGE' && targetExists && parsed.mergedContent && parsed.targetId) {
+                return { action: 'MERGE', memory: draft, mergedContent: parsed.mergedContent, targetId: parsed.targetId };
+            }
+            if (parsed.action === 'SKIP') {
+                return { action: 'SKIP', memory: draft };
+            }
+            return { action: 'CREATE', memory: draft };
+        }
+        catch (error) {
+            // On any error, default to CREATE (fail-open)
+            const msg = error instanceof Error ? error.message : String(error);
+            console.debug(`[MemoryDeduplicator] Failed for ${draft.category}: ${msg}`);
+            return { action: 'CREATE', memory: draft };
+        }
+    }
+}

package/dist/agent/infra/memory/memory-manager.d.ts

@@ -20,6 +20,7 @@ import type { ILogger } from '../../core/interfaces/i-logger.js';
  */
 export declare class MemoryManager {
     private blobStorage;
+    private static readonly MEMORY_ID_LENGTH;
     private static readonly MEMORY_KEY_PREFIX;
     private readonly logger;
     constructor(blobStorage: IBlobStorage, logger?: ILogger);

package/dist/agent/infra/memory/memory-manager.js

@@ -105,6 +105,7 @@ const ListMemoriesOptionsSchema = z
  */
 export class MemoryManager {
     blobStorage;
+    static MEMORY_ID_LENGTH = 12;
     static MEMORY_KEY_PREFIX = 'memory-';
     logger;
     constructor(blobStorage, logger) {
@@ -468,11 +469,11 @@ export class MemoryManager {
         if (!key.startsWith(MemoryManager.MEMORY_KEY_PREFIX)) {
             return false;
         }
-        // Memory keys have format: memory-{id}
-        // Attachment keys have format: memory-{id}-{suffix}
-        // Count dashes: memory keys have 1 dash, attachments have 2+
-        const dashCount = (key.match(/-/g) || []).length;
-        return dashCount === 1;
+        // Memory keys have format: memory-{id} where id is a fixed-length nanoid(12).
+        // Attachment keys append an extra suffix: memory-{id}-{suffix}.
+        // A valid memory id may itself contain '-', so counting dashes is incorrect.
+        const suffix = key.slice(MemoryManager.MEMORY_KEY_PREFIX.length);
+        return suffix.length === MemoryManager.MEMORY_ID_LENGTH;
     }
     /**
      * Load all memories from blob storage

package/dist/agent/infra/sandbox/curate-service.d.ts

@@ -3,13 +3,15 @@
  * Wraps the curate-tool logic for use in the sandbox's tools.* SDK.
  */
 import type { CurateOperation, CurateOptions, CurateResult, DetectDomainsInput, DetectDomainsResult, ICurateService } from '../../core/interfaces/i-curate-service.js';
+import type { AbstractGenerationQueue } from '../map/abstract-queue.js';
 /**
  * Curate service implementation.
  * Provides curate and domain detection operations for the sandbox.
  */
 export declare class CurateService implements ICurateService {
+    private readonly abstractQueue?;
     private readonly workingDirectory;
-    constructor(workingDirectory?: string);
+    constructor(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue | undefined);
     /**
      * Execute curate operations on knowledge topics.
      *
@@ -33,4 +35,4 @@ export declare class CurateService implements ICurateService {
  * @param workingDirectory - Working directory for resolving relative paths
  * @returns CurateService instance
  */
-export declare function createCurateService(workingDirectory?: string): ICurateService;
+export declare function createCurateService(workingDirectory?: string, abstractQueue?: AbstractGenerationQueue): ICurateService;

package/dist/agent/infra/sandbox/curate-service.js

@@ -72,8 +72,10 @@ function validateOperations(operations) {
  * Provides curate and domain detection operations for the sandbox.
  */
 export class CurateService {
+    abstractQueue;
     workingDirectory;
-    constructor(workingDirectory) {
+    constructor(workingDirectory, abstractQueue) {
+        this.abstractQueue = abstractQueue;
         this.workingDirectory = workingDirectory ?? process.cwd();
     }
     /**
@@ -104,10 +106,7 @@ export class CurateService {
             };
         }
         // Call the underlying executeCurate function from curate-tool
-        const result = await executeCurate({
-            basePath,
-            operations,
-        });
+        const result = await executeCurate({ basePath, operations }, undefined, this.abstractQueue);
         return result;
     }
     /**
@@ -146,6 +145,6 @@ export class CurateService {
  * @param workingDirectory - Working directory for resolving relative paths
  * @returns CurateService instance
  */
-export function createCurateService(workingDirectory) {
-    return new CurateService(workingDirectory);
+export function createCurateService(workingDirectory, abstractQueue) {
+    return new CurateService(workingDirectory, abstractQueue);
 }

package/dist/agent/infra/sandbox/local-sandbox.d.ts

@@ -22,6 +22,8 @@ export declare class LocalSandbox {
     /** Value set by setFinalResult() — signals early exit */
     private finalResult?;
     private outputBuffer;
+    /** Async tool calls started inside the sandbox, including unawaited ones. */
+    private pendingToolPromises;
     /** Current stdout cap in chars (undefined = unlimited) */
     private stdoutCap?;
     /** Running count of chars written to outputBuffer in current execution */
@@ -50,9 +52,12 @@ export declare class LocalSandbox {
      * @param updates - Key-value pairs to add to context
      */
     updateContext(updates: Record<string, unknown>): void;
+    private awaitPendingToolPromises;
     /**
      * Push a line to stdout, respecting the optional character cap.
      * When the cap is reached, appends a truncation notice and drops further output.
      */
     private pushStdout;
+    private trackPromise;
+    private wrapToolObject;
 }

package/dist/agent/infra/sandbox/local-sandbox.js

@@ -87,6 +87,8 @@ export class LocalSandbox {
     /** Value set by setFinalResult() — signals early exit */
     finalResult;
     outputBuffer = [];
+    /** Async tool calls started inside the sandbox, including unawaited ones. */
+    pendingToolPromises = new Set();
     /** Current stdout cap in chars (undefined = unlimited) */
     stdoutCap;
     /** Running count of chars written to outputBuffer in current execution */
@@ -118,7 +120,7 @@ export class LocalSandbox {
         };
         // Inject Tools SDK if provided (for file system operations)
         if (toolsSDK) {
-            sandbox.tools = toolsSDK;
+            sandbox.tools = this.wrapToolObject(toolsSDK);
         }
         // Inject environment context as `env` object if provided
         if (environmentContext) {
@@ -152,6 +154,7 @@ export class LocalSandbox {
         this.outputBuffer = [];
         this.errorBuffer = [];
         this.finalResult = undefined;
+        this.pendingToolPromises.clear();
         this.stdoutCap = config?.maxStdoutChars;
         this.stdoutCharsWritten = 0;
         this.stdoutTruncated = false;
@@ -192,6 +195,8 @@ export class LocalSandbox {
                     }
                 }
             }
+            const elapsedMs = performance.now() - startTime;
+            await this.awaitPendingToolPromises(Math.max(0, timeout - elapsedMs));
         }
         catch (error) {
             const errorMessage = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
@@ -243,6 +248,32 @@ export class LocalSandbox {
             this.context[key] = value;
         }
     }
+    async awaitPendingToolPromises(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        /* eslint-disable no-await-in-loop */
+        while (this.pendingToolPromises.size > 0) {
+            const pending = [...this.pendingToolPromises];
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw new Error('Async execution timeout');
+            }
+            let timeoutId;
+            try {
+                await Promise.race([
+                    Promise.allSettled(pending),
+                    new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error('Async execution timeout')), remaining);
+                    }),
+                ]);
+            }
+            finally {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+    }
     /**
      * Push a line to stdout, respecting the optional character cap.
      * When the cap is reached, appends a truncation notice and drops further output.
@@ -263,4 +294,29 @@ export class LocalSandbox {
         this.stdoutCharsWritten += line.length + 1; // +1 for join newline
         this.outputBuffer.push(line);
     }
+    trackPromise(promise) {
+        const trackedPromise = promise.finally(() => {
+            this.pendingToolPromises.delete(trackedPromise);
+        });
+        this.pendingToolPromises.add(trackedPromise);
+        return trackedPromise;
+    }
+    wrapToolObject(value) {
+        if (typeof value === 'function') {
+            const original = value;
+            const wrapped = (...args) => {
+                const result = original(...args);
+                const isPromiseLike = result !== null &&
+                    typeof result === 'object' &&
+                    typeof result.then === 'function';
+                return isPromiseLike ? this.trackPromise(Promise.resolve(result)) : result;
+            };
+            return wrapped;
+        }
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const wrappedEntries = Object.entries(value).map(([key, child]) => ([key, this.wrapToolObject(child)]));
+            return Object.fromEntries(wrappedEntries);
+        }
+        return value;
+    }
 }

package/dist/agent/infra/sandbox/tools-sdk.d.ts

@@ -74,11 +74,13 @@ export interface SearchKnowledgeResult {
         /** Number of other memories that reference this one */
         backlinkCount?: number;
         excerpt: string;
+        /** Path to .overview.md for this entry; present when L1 overview exists */
+        overviewPath?: string;
         path: string;
         /** Top backlink source paths (max 3) */
         relatedPaths?: string[];
         score: number;
-        /** Symbol kind: 'domain' | 'topic' | 'subtopic' | 'context' | 'archive_stub' */
+        /** Symbol kind: 'domain' | 'topic' | 'subtopic' | 'context' | 'archive_stub' | 'summary' */
         symbolKind?: string;
         /** Resolved hierarchical path in the symbol tree */
         symbolPath?: string;

package/dist/agent/infra/session/session-compressor.d.ts

@@ -0,0 +1,43 @@
+import type { IContentGenerator } from '../../core/interfaces/i-content-generator.js';
+import type { InternalMessage } from '../../core/interfaces/message-types.js';
+import type { MemoryDeduplicator } from '../memory/memory-deduplicator.js';
+import type { MemoryManager } from '../memory/memory-manager.js';
+/**
+ * Result of a session compression pass.
+ */
+export interface CompressionResult {
+    created: number;
+    merged: number;
+    skipped: number;
+}
+/**
+ * Extracts and persists memories from a completed task session.
+ *
+ * Flow:
+ * 1. Serialize session messages into a text digest
+ * 2. LLM call: extract 5-category draft memories
+ * 3. Load existing agent memories for deduplication
+ * 4. Apply deduplication decisions (CREATE/MERGE/SKIP)
+ */
+export declare class SessionCompressor {
+    private readonly deduplicator;
+    private readonly generator;
+    private readonly memoryManager;
+    constructor(deduplicator: MemoryDeduplicator, generator: IContentGenerator, memoryManager: MemoryManager);
+    /**
+     * Compress a session into persistent memories.
+     *
+     * @param messages - Session message history
+     * @param commandType - Session command type (e.g. 'curate', 'query')
+     * @param options - Compression options
+     * @param options.minMessages - Minimum message count required before compression runs
+     * @returns Summary of actions taken
+     */
+    compress(messages: InternalMessage[], commandType: string, options?: {
+        minMessages?: number;
+    }): Promise<CompressionResult>;
+    private buildFallbackDrafts;
+    private deduplicateFallbackDrafts;
+    private extractDrafts;
+    private serializeMessages;
+}

package/dist/agent/infra/session/session-compressor.js

@@ -0,0 +1,296 @@
+import { randomUUID } from 'node:crypto';
+import { streamToText } from '../llm/stream-to-text.js';
+/**
+ * Five extraction categories for ByteRover session memories.
+ */
+const CATEGORIES = ['DECISIONS', 'ENTITIES', 'PATTERNS', 'PREFERENCES', 'SKILLS'];
+const SYSTEM_PROMPT = `You are a session memory extractor for ByteRover, a code intelligence tool.
+Extract reusable memories from the conversation in exactly these 5 categories:
+- PATTERNS: reusable code or workflow patterns discovered
+- PREFERENCES: user style/naming/structure decisions
+- ENTITIES: key files, modules, APIs, dependencies discovered
+- DECISIONS: architectural choices (always extract, even if already known — immutable log)
+- SKILLS: tool invocation recipes that worked
+
+Return ONLY a JSON array of memory objects:
+[{"category": "PATTERNS", "content": "...", "tags": ["optional"]}, ...]
+
+Extract 0-3 memories per category. Skip categories with nothing new. Be concise (max 200 chars per memory).`;
+const MAX_DIGEST_CHARS = 12_000;
+const FALLBACK_DIGEST_PREVIEW_CHARS = 4000;
+const MIN_BOUNDARY_RATIO = 0.6;
+const SOURCE_PATH_PATTERN = /\b(?:src|app|lib|packages|docs|test|tests)\/[A-Za-z0-9_./-]+\b/g;
+function truncateDigestAtBoundary(digest, maxChars = MAX_DIGEST_CHARS) {
+    if (digest.length <= maxChars) {
+        return digest;
+    }
+    const clipped = digest.slice(0, maxChars);
+    const boundary = clipped.lastIndexOf('\n\n');
+    // Prefer a natural message boundary when it falls reasonably close to the cap.
+    return boundary >= Math.floor(maxChars * MIN_BOUNDARY_RATIO) ? clipped.slice(0, boundary) : clipped;
+}
+/**
+ * Extracts and persists memories from a completed task session.
+ *
+ * Flow:
+ * 1. Serialize session messages into a text digest
+ * 2. LLM call: extract 5-category draft memories
+ * 3. Load existing agent memories for deduplication
+ * 4. Apply deduplication decisions (CREATE/MERGE/SKIP)
+ */
+export class SessionCompressor {
+    deduplicator;
+    generator;
+    memoryManager;
+    constructor(deduplicator, generator, memoryManager) {
+        this.deduplicator = deduplicator;
+        this.generator = generator;
+        this.memoryManager = memoryManager;
+    }
+    /**
+     * Compress a session into persistent memories.
+     *
+     * @param messages - Session message history
+     * @param commandType - Session command type (e.g. 'curate', 'query')
+     * @param options - Compression options
+     * @param options.minMessages - Minimum message count required before compression runs
+     * @returns Summary of actions taken
+     */
+    async compress(messages, commandType, options) {
+        const minMessages = options?.minMessages ?? 4;
+        const hasAssistantContent = messages.some((message) => (message.role === 'assistant' &&
+            getMessageText(message).trim().length > 0));
+        const effectiveMinMessages = commandType.startsWith('curate') && hasAssistantContent
+            ? Math.min(minMessages, 1)
+            : minMessages;
+        if (messages.length < effectiveMinMessages) {
+            return { created: 0, merged: 0, skipped: 0 };
+        }
+        const digest = this.serializeMessages(messages);
+        if (!digest.trim()) {
+            return { created: 0, merged: 0, skipped: 0 };
+        }
+        // Step 1: Extract draft memories via LLM
+        const useFallbackDraftsFirst = shouldPreferFallbackDrafts(commandType);
+        let drafts = useFallbackDraftsFirst ? this.buildFallbackDrafts(digest, commandType) : await this.extractDrafts(digest, commandType);
+        let usedFallbackDrafts = useFallbackDraftsFirst && drafts.length > 0;
+        if (drafts.length === 0) {
+            drafts = this.buildFallbackDrafts(digest, commandType);
+            usedFallbackDrafts = drafts.length > 0;
+        }
+        if (drafts.length === 0) {
+            return { created: 0, merged: 0, skipped: 0 };
+        }
+        // Step 2: Load the most recently updated agent memories for deduplication.
+        // MemoryManager.list() sorts by updatedAt DESC before applying the limit.
+        const existing = await this.memoryManager.list({ limit: 60, source: 'agent' });
+        // Step 3: Deduplicate
+        const actions = usedFallbackDrafts
+            ? this.deduplicateFallbackDrafts(drafts, existing)
+            : await this.deduplicator.deduplicate(drafts, existing);
+        // Step 4: Apply decisions
+        let created = 0;
+        let merged = 0;
+        let skipped = 0;
+        /* eslint-disable no-await-in-loop */
+        for (const action of actions) {
+            try {
+                if (action.action === 'CREATE') {
+                    await this.memoryManager.create({
+                        content: action.memory.content,
+                        metadata: { category: action.memory.category, source: 'agent' },
+                        tags: action.memory.tags,
+                    });
+                    created++;
+                }
+                else if (action.action === 'MERGE') {
+                    await this.memoryManager.update(action.targetId, { content: action.mergedContent });
+                    merged++;
+                }
+                else {
+                    skipped++;
+                }
+            }
+            catch (error) {
+                // Fail-open: skip individual memory errors
+                const msg = error instanceof Error ? error.message : String(error);
+                console.debug(`[SessionCompressor] Failed to apply ${action.action} action: ${msg}`);
+                skipped++;
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        return { created, merged, skipped };
+    }
+    buildFallbackDrafts(digest, commandType) {
+        if (!commandType.startsWith('curate')) {
+            return [];
+        }
+        const preview = digest.slice(0, FALLBACK_DIGEST_PREVIEW_CHARS);
+        const fingerprint = computeFingerprint(preview);
+        const sourcePaths = [...new Set((preview.match(SOURCE_PATH_PATTERN) ?? []).filter((path) => !path.startsWith('.brv/')))];
+        const moduleLabel = deriveModuleLabel(sourcePaths);
+        const tags = moduleLabel === 'the working module' ? undefined : [moduleLabel];
+        return [
+            {
+                category: 'DECISIONS',
+                content: `Session ${fingerprint}: curated ${moduleLabel} knowledge into the context tree.`,
+                tags,
+            },
+            {
+                category: 'DECISIONS',
+                content: `Session ${fingerprint}: preserved ${moduleLabel} findings as durable knowledge instead of chat-only context.`,
+                tags,
+            },
+            {
+                category: 'PATTERNS',
+                content: `Session ${fingerprint}: used recon -> extraction -> curate apply workflow for ${moduleLabel}.`,
+                tags,
+            },
+            {
+                category: 'PATTERNS',
+                content: `Session ${fingerprint}: separated durable notes from raw source snippets while curating ${moduleLabel}.`,
+                tags,
+            },
+            {
+                category: 'SKILLS',
+                content: `Session ${fingerprint}: start ${commandType} with tools.curation.recon, then mapExtract, then verify applied file paths.`,
+                tags,
+            },
+            {
+                category: 'ENTITIES',
+                content: `${moduleLabel} is an actively curated module surfaced during ${commandType}.`,
+                tags,
+            },
+        ];
+    }
+    deduplicateFallbackDrafts(drafts, existing) {
+        const dedupCategories = ['ENTITIES', 'PATTERNS', 'SKILLS'];
+        const existingKeys = new Map();
+        for (const category of dedupCategories) {
+            existingKeys.set(category, new Set(existing
+                .filter((memory) => getMemoryCategory(memory) === category)
+                .map((memory) => normalizeForFallbackDedup(memory.content, category))));
+        }
+        return drafts.map((memory) => {
+            // DECISIONS always CREATE — temporal audit records that should accumulate
+            if (memory.category === 'DECISIONS') {
+                return { action: 'CREATE', memory };
+            }
+            const categorySet = existingKeys.get(memory.category);
+            if (!categorySet) {
+                return { action: 'CREATE', memory };
+            }
+            const key = normalizeForFallbackDedup(memory.content, memory.category);
+            if (categorySet.has(key)) {
+                return { action: 'SKIP', memory };
+            }
+            categorySet.add(key);
+            return { action: 'CREATE', memory };
+        });
+    }
+    async extractDrafts(digest, commandType) {
+        try {
+            const truncatedDigest = truncateDigestAtBoundary(digest);
+            const prompt = `## Session Type: ${commandType}
+
+## Conversation
+${truncatedDigest}
+
+Extract reusable memories from this session.`;
+            // Use streaming — ChatGPT OAuth Codex endpoint requires stream: true
+            const responseText = await streamToText(this.generator, {
+                config: { maxTokens: 1000, temperature: 0 },
+                contents: [{ content: prompt, role: 'user' }],
+                model: 'default',
+                systemPrompt: SYSTEM_PROMPT,
+                taskId: randomUUID(),
+            });
+            // Strip markdown code fences — some providers wrap JSON in ```json ... ```
+            const jsonText = responseText.replace(/^```(?:json)?\s*\n?/i, '').replace(/\n?```\s*$/i, '').trim();
+            const parsed = JSON.parse(jsonText);
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed
+                .filter((item) => CATEGORIES.includes(item.category) && item.content?.trim())
+                .map((item) => ({
+                category: item.category,
+                content: item.content.trim(),
+                tags: item.tags,
+            }));
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            console.debug(`[SessionCompressor] Failed to extract drafts (${commandType}): ${msg}`);
+            return [];
+        }
+    }
+    serializeMessages(messages) {
+        const lines = [];
+        for (const msg of messages) {
+            const role = msg.role.toUpperCase();
+            const text = getMessageText(msg);
+            if (text.trim()) {
+                lines.push(`[${role}]: ${text.slice(0, 2000)}`);
+            }
+        }
+        return lines.join('\n\n');
+    }
+}
+function getMessageText(message) {
+    if (typeof message.content === 'string') {
+        return message.content;
+    }
+    if (!Array.isArray(message.content)) {
+        return '';
+    }
+    return message.content
+        .filter((part) => 'text' in part && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join(' ');
+}
+function computeFingerprint(text) {
+    /* eslint-disable no-bitwise, unicorn/prefer-code-point */
+    let hash = 0;
+    for (const char of text) {
+        hash = (hash * 31 + char.charCodeAt(0)) >>> 0;
+    }
+    /* eslint-enable no-bitwise, unicorn/prefer-code-point */
+    return hash.toString(16).padStart(8, '0').slice(0, 8);
+}
+function deriveModuleLabel(sourcePaths) {
+    if (sourcePaths.length === 0) {
+        return 'the working module';
+    }
+    const firstPath = sourcePaths[0];
+    const segments = firstPath.split('/').filter(Boolean);
+    if (segments.length >= 2) {
+        return `${segments[0]}/${segments[1]}`;
+    }
+    return firstPath;
+}
+function normalizeMemoryContent(content) {
+    return content.trim().toLowerCase().replaceAll(/\s+/g, ' ');
+}
+function normalizeForFallbackDedup(content, category) {
+    let normalized = normalizeMemoryContent(content);
+    // PATTERNS and SKILLS are session-fingerprinted ("Session abc123: ...").
+    // Strip the prefix so repeated curate sessions on the same module are detected as duplicates.
+    if (category === 'PATTERNS' || category === 'SKILLS') {
+        normalized = normalized.replace(/^session\s+\S+:\s*/, '');
+    }
+    return normalized;
+}
+function getMemoryCategory(memory) {
+    if (!memory.metadata || typeof memory.metadata !== 'object') {
+        return undefined;
+    }
+    const { category } = memory.metadata;
+    return typeof category === 'string' ? category : undefined;
+}
+// Curate sessions always use deterministic fallback drafts instead of LLM extraction.
+// Fallback drafts are faster (no LLM call), cheaper, and produce consistent categorized
+// memories that can be deduped via string matching. LLM extraction is reserved for
+// non-curate sessions (e.g., query) where conversation content is unpredictable.
+function shouldPreferFallbackDrafts(commandType) {
+    return commandType.startsWith('curate');
+}

package/dist/agent/infra/session/session-manager.d.ts

@@ -160,6 +160,13 @@ export declare class SessionManager {
      * @returns Session instance or undefined if not found
      */
     getSession(id: string): IChatSession | undefined;
+    /**
+     * Get the command type (agent name) registered for a session.
+     *
+     * @param id - Session ID
+     * @returns Command type string (e.g. 'curate', 'query') or undefined if not found
+     */
+    getSessionCommandType(id: string): string | undefined;
     /**
      * Get the number of active sessions.
      *