@machina.ai/cell-cli-core 1.38.1-rc2 → 1.40.1-rc2

package/dist/src/services/memoryService.js

@@ -7,8 +7,10 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { constants as fsConstants } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-import { SESSION_FILE_PREFIX, } from './chatRecordingService.js';
+import * as Diff from 'diff';
+import { SESSION_FILE_PREFIX, loadConversationRecord, } from './chatRecordingService.js';
 import { debugLogger } from '../utils/debugLogger.js';
+import { coreEvents } from '../utils/events.js';
 import { isNodeError } from '../utils/errors.js';
 import { FRONTMATTER_REGEX, parseFrontmatter } from '../skills/skillLoader.js';
 import { LocalAgentExecutor } from '../agents/local-executor.js';
@@ -21,19 +23,30 @@ import { PolicyEngine } from '../policy/policy-engine.js';
 import { PolicyDecision } from '../policy/types.js';
 import { MessageBus } from '../confirmation-bus/message-bus.js';
 import { Storage } from '../config/storage.js';
+import { READ_FILE_TOOL_NAME } from '../tools/tool-names.js';
+import { applyParsedSkillPatches, hasParsedPatchHunks, } from './memoryPatchUtils.js';
 const LOCK_FILENAME = '.extraction.lock';
 const STATE_FILENAME = '.extraction-state.json';
 const LOCK_STALE_MS = 35 * 60 * 1000; // 35 minutes (exceeds agent's 30-min time limit)
 const MIN_USER_MESSAGES = 10;
 const MIN_IDLE_MS = 3 * 60 * 60 * 1000; // 3 hours
 const MAX_SESSION_INDEX_SIZE = 50;
+const MAX_NEW_SESSION_BATCH_SIZE = 10;
+function hasProperty(obj, prop) {
+    return obj !== null && typeof obj === 'object' && prop in obj;
+}
+function isStringProperty(obj, prop) {
+    return hasProperty(obj, prop) && typeof obj[prop] === 'string';
+}
 /**
  * Returns all session IDs that have been processed across all runs.
  */
 export function getProcessedSessionIds(state) {
     const ids = new Set();
     for (const run of state.runs) {
-        for (const id of run.sessionIds) {
+        const processedSessionIds = run.processedSessions?.map((session) => session.sessionId) ??
+            run.sessionIds;
+        for (const id of processedSessionIds) {
             ids.add(id);
         }
     }
@@ -47,26 +60,35 @@ function isLockInfo(value) {
         'startedAt' in value &&
         typeof value.startedAt === 'string');
 }
-function isConversationRecord(value) {
+function isSessionVersion(value) {
     return (typeof value === 'object' &&
         value !== null &&
         'sessionId' in value &&
         typeof value.sessionId === 'string' &&
-        'messages' in value &&
-        Array.isArray(value.messages) &&
-        'projectHash' in value &&
-        'startTime' in value &&
-        'lastUpdated' in value);
+        'lastUpdated' in value &&
+        typeof value.lastUpdated === 'string');
 }
-function isExtractionRun(value) {
+function normalizeSessionVersions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isSessionVersion).map((session) => ({
+        sessionId: session.sessionId,
+        lastUpdated: session.lastUpdated,
+    }));
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string');
+}
+function isExtractionRunLike(value) {
     return (typeof value === 'object' &&
         value !== null &&
         'runAt' in value &&
         typeof value.runAt === 'string' &&
-        'sessionIds' in value &&
-        Array.isArray(value.sessionIds) &&
-        'skillsCreated' in value &&
-        Array.isArray(value.skillsCreated));
+        'skillsCreated' in value);
 }
 function isExtractionState(value) {
     return (typeof value === 'object' &&
@@ -74,6 +96,123 @@ function isExtractionState(value) {
         'runs' in value &&
         Array.isArray(value.runs));
 }
+function buildExtractionRun(value) {
+    if (!isExtractionRunLike(value)) {
+        return null;
+    }
+    const candidateSessions = normalizeSessionVersions(value.candidateSessions);
+    const processedSessions = normalizeSessionVersions(value.processedSessions);
+    const sessionIds = normalizeStringArray(value.sessionIds);
+    return {
+        runAt: value.runAt,
+        sessionIds: sessionIds.length > 0
+            ? sessionIds
+            : processedSessions.map((session) => session.sessionId),
+        candidateSessions: candidateSessions.length > 0 ? candidateSessions : undefined,
+        processedSessions: processedSessions.length > 0 ? processedSessions : undefined,
+        skillsCreated: normalizeStringArray(value.skillsCreated),
+    };
+}
+function getTimestampMs(timestamp) {
+    const parsed = Date.parse(timestamp);
+    return Number.isNaN(parsed) ? 0 : parsed;
+}
+function getSessionVersionKey(session) {
+    return `${session.sessionId}\u0000${session.lastUpdated}`;
+}
+function hasLegacyRunProcessedSession(run, session) {
+    return (run.sessionIds.includes(session.sessionId) &&
+        getTimestampMs(run.runAt) >= getTimestampMs(session.lastUpdated));
+}
+function isSessionVersionProcessed(state, session) {
+    const sessionKey = getSessionVersionKey(session);
+    for (const run of state.runs) {
+        if (run.processedSessions?.some((processed) => getSessionVersionKey(processed) === sessionKey)) {
+            return true;
+        }
+        if (!run.processedSessions && hasLegacyRunProcessedSession(run, session)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getSessionAttemptCount(state, session) {
+    const sessionKey = getSessionVersionKey(session);
+    let attempts = 0;
+    for (const run of state.runs) {
+        if (run.candidateSessions) {
+            if (run.candidateSessions.some((candidate) => getSessionVersionKey(candidate) === sessionKey)) {
+                attempts++;
+            }
+            continue;
+        }
+        if (hasLegacyRunProcessedSession(run, session)) {
+            attempts++;
+        }
+    }
+    return attempts;
+}
+function compareIndexedSessions(a, b) {
+    const timestampDelta = getTimestampMs(b.lastUpdated) - getTimestampMs(a.lastUpdated);
+    if (timestampDelta !== 0) {
+        return timestampDelta;
+    }
+    if (a.filePath.endsWith('.jsonl') !== b.filePath.endsWith('.jsonl')) {
+        return a.filePath.endsWith('.jsonl') ? -1 : 1;
+    }
+    return b.filePath.localeCompare(a.filePath);
+}
+function shouldReplaceIndexedSession(existing, candidate) {
+    return compareIndexedSessions(candidate, existing) < 0;
+}
+function isReadFileStartActivity(activity) {
+    return (activity.type === 'TOOL_CALL_START' &&
+        activity.data['name'] === READ_FILE_TOOL_NAME);
+}
+function getResolvedReadFilePath(config, activity) {
+    if (!isReadFileStartActivity(activity)) {
+        return null;
+    }
+    const args = activity.data.args;
+    if (typeof args !== 'object' ||
+        args === null ||
+        !('file_path' in args) ||
+        typeof args.file_path !== 'string') {
+        return null;
+    }
+    return path.resolve(config.getTargetDir(), args.file_path);
+}
+function getReadFileStartCallId(activity) {
+    if (!isReadFileStartActivity(activity) ||
+        !isStringProperty(activity.data, 'callId')) {
+        return null;
+    }
+    return activity.data.callId;
+}
+function getCompletedReadFileCallId(activity) {
+    if (activity.type !== 'TOOL_CALL_END' ||
+        activity.data['name'] !== READ_FILE_TOOL_NAME ||
+        !isStringProperty(activity.data, 'id')) {
+        return null;
+    }
+    return activity.data['id'];
+}
+function getFailedReadFileCallId(activity) {
+    if (activity.type !== 'ERROR' ||
+        activity.data['name'] !== READ_FILE_TOOL_NAME ||
+        !isStringProperty(activity.data, 'callId')) {
+        return null;
+    }
+    return activity.data['callId'];
+}
+function getUserMessageCount(conversation) {
+    return (conversation.userMessageCount ??
+        conversation.messages.filter((message) => message.type === 'user').length);
+}
+function isSupportedSessionFile(fileName) {
+    return (fileName.startsWith(SESSION_FILE_PREFIX) &&
+        (fileName.endsWith('.json') || fileName.endsWith('.jsonl')));
+}
 /**
  * Attempts to acquire an exclusive lock file using O_CREAT | O_EXCL.
  * Returns true if the lock was acquired, false if another instance owns it.
@@ -165,13 +304,10 @@ export async function readExtractionState(statePath) {
         }
         const runs = [];
         for (const run of parsed.runs) {
-            if (!isExtractionRun(run))
+            const normalizedRun = buildExtractionRun(run);
+            if (!normalizedRun)
                 continue;
-            runs.push({
-                runAt: run.runAt,
-                sessionIds: run.sessionIds.filter((sid) => typeof sid === 'string'),
-                skillsCreated: run.skillsCreated.filter((sk) => typeof sk === 'string'),
-            });
+            runs.push(normalizedRun);
         }
         return { runs };
     }
@@ -198,18 +334,20 @@ function shouldProcessConversation(parsed) {
     if (parsed.kind === 'subagent')
         return false;
     // Skip sessions that are still active (not idle for 3+ hours)
-    const lastUpdated = new Date(parsed.lastUpdated).getTime();
+    const lastUpdated = getTimestampMs(parsed.lastUpdated);
     if (Date.now() - lastUpdated < MIN_IDLE_MS)
         return false;
     // Skip sessions with too few user messages
-    const userMessageCount = parsed.messages.filter((m) => m.type === 'user').length;
-    if (userMessageCount < MIN_USER_MESSAGES)
+    if (getUserMessageCount(parsed) < MIN_USER_MESSAGES)
         return false;
     return true;
 }
 /**
- * Scans the chats directory for eligible session files (sorted most-recent-first,
- * capped at MAX_SESSION_INDEX_SIZE). Shared by buildSessionIndex.
+ * Scans the chats directory for eligible session files, loading metadata from
+ * both JSONL and legacy JSON sessions, deduplicating migrated sessions by
+ * session ID, and sorting by actual lastUpdated. We scan the full directory
+ * here so already-processed recent sessions cannot permanently block older
+ * backlog sessions from surfacing as new candidates.
  */
 async function scanEligibleSessions(chatsDir) {
     let allFiles;
@@ -219,55 +357,94 @@ async function scanEligibleSessions(chatsDir) {
     catch {
         return [];
     }
-    const sessionFiles = allFiles.filter((f) => f.startsWith(SESSION_FILE_PREFIX) && f.endsWith('.json'));
-    // Sort by filename descending (most recent first)
-    sessionFiles.sort((a, b) => b.localeCompare(a));
-    const results = [];
-    for (const file of sessionFiles) {
-        if (results.length >= MAX_SESSION_INDEX_SIZE)
-            break;
+    const candidates = [];
+    for (const file of allFiles) {
+        if (!isSupportedSessionFile(file))
+            continue;
         const filePath = path.join(chatsDir, file);
         try {
-            const content = await fs.readFile(filePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            if (!isConversationRecord(parsed))
+            const stat = await fs.stat(filePath);
+            if (!stat.isFile())
                 continue;
-            if (!shouldProcessConversation(parsed))
+            candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+        }
+        catch {
+            // Skip files that disappeared between readdir and stat.
+        }
+    }
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const latestBySessionId = new Map();
+    for (const { filePath } of candidates) {
+        try {
+            const conversation = await loadConversationRecord(filePath, {
+                metadataOnly: true,
+            });
+            if (!conversation || !shouldProcessConversation(conversation))
                 continue;
-            results.push({ conversation: parsed, filePath });
+            const indexedSession = {
+                sessionId: conversation.sessionId,
+                lastUpdated: conversation.lastUpdated,
+                filePath,
+                summary: conversation.summary,
+                userMessageCount: getUserMessageCount(conversation),
+            };
+            const existing = latestBySessionId.get(indexedSession.sessionId);
+            if (!existing || shouldReplaceIndexedSession(existing, indexedSession)) {
+                latestBySessionId.set(indexedSession.sessionId, indexedSession);
+            }
         }
         catch {
             // Skip unreadable files
         }
     }
-    return results;
+    return Array.from(latestBySessionId.values()).sort(compareIndexedSessions);
 }
 /**
  * Builds a session index for the extraction agent: a compact listing of all
  * eligible sessions with their summary, file path, and new/previously-processed status.
  * The agent can use read_file on paths to inspect sessions that look promising.
  *
- * Returns the index text and the list of new (unprocessed) session IDs.
+ * Returns the index text, the list of selected new (unprocessed) session IDs,
+ * and the surfaced candidate sessions for this run.
  */
 export async function buildSessionIndex(chatsDir, state) {
-    const processedSet = getProcessedSessionIds(state);
     const eligible = await scanEligibleSessions(chatsDir);
     if (eligible.length === 0) {
-        return { sessionIndex: '', newSessionIds: [] };
+        return { sessionIndex: '', newSessionIds: [], candidateSessions: [] };
     }
-    const lines = [];
-    const newSessionIds = [];
-    for (const { conversation, filePath } of eligible) {
-        const userMessageCount = conversation.messages.filter((m) => m.type === 'user').length;
-        const isNew = !processedSet.has(conversation.sessionId);
-        if (isNew) {
-            newSessionIds.push(conversation.sessionId);
+    const newSessions = [];
+    const oldSessions = [];
+    for (const session of eligible) {
+        if (isSessionVersionProcessed(state, session)) {
+            oldSessions.push(session);
+        }
+        else {
+            newSessions.push(session);
         }
-        const status = isNew ? '[NEW]' : '[old]';
-        const summary = conversation.summary ?? '(no summary)';
-        lines.push(`${status} ${summary} (${userMessageCount} user msgs) — ${filePath}`);
     }
-    return { sessionIndex: lines.join('\n'), newSessionIds };
+    newSessions.sort((a, b) => {
+        const attemptDelta = getSessionAttemptCount(state, a) - getSessionAttemptCount(state, b);
+        if (attemptDelta !== 0) {
+            return attemptDelta;
+        }
+        return compareIndexedSessions(a, b);
+    });
+    const candidateSessions = newSessions.slice(0, MAX_NEW_SESSION_BATCH_SIZE);
+    const remainingSlots = Math.max(0, MAX_SESSION_INDEX_SIZE - candidateSessions.length);
+    const displayedOldSessions = oldSessions.slice(0, remainingSlots);
+    const candidateSessionIds = new Set(candidateSessions.map((session) => getSessionVersionKey(session)));
+    const lines = [...candidateSessions, ...displayedOldSessions].map((session) => {
+        const status = candidateSessionIds.has(getSessionVersionKey(session))
+            ? '[NEW]'
+            : '[old]';
+        const summary = session.summary ?? '(no summary)';
+        return `${status} ${summary} (${session.userMessageCount} user msgs) — ${session.filePath}`;
+    });
+    return {
+        sessionIndex: lines.join('\n'),
+        newSessionIds: candidateSessions.map((session) => session.sessionId),
+        candidateSessions,
+    };
 }
 /**
  * Builds a summary of all existing skills — both memory-extracted skills
@@ -318,20 +495,19 @@ async function buildExistingSkillsSummary(skillsDir, config) {
             const extensionSkills = [];
             const builtinSkills = [];
             for (const s of discoveredSkills) {
-                const entry = `- **${s.name}**: ${s.description}`;
                 const loc = s.location;
                 if (loc.includes('/bundle/') || loc.includes('\\bundle\\')) {
-                    builtinSkills.push(entry);
+                    builtinSkills.push(`- **${s.name}**: ${s.description}`);
                 }
                 else if (loc.startsWith(userSkillsDir)) {
-                    globalSkills.push(entry);
+                    globalSkills.push(`- **${s.name}**: ${s.description} (${loc})`);
                 }
                 else if (loc.includes('/extensions/') ||
                     loc.includes('\\extensions\\')) {
-                    extensionSkills.push(entry);
+                    extensionSkills.push(`- **${s.name}**: ${s.description}`);
                 }
                 else {
-                    workspaceSkills.push(entry);
+                    workspaceSkills.push(`- **${s.name}**: ${s.description} (${loc})`);
                 }
             }
             if (globalSkills.length > 0) {
@@ -380,6 +556,82 @@ function buildAgentLoopContext(config) {
         sandboxManager: config.sandboxManager,
     };
 }
+/**
+ * Validates all .patch files in the skills directory using the `diff` library.
+ * Parses each patch, reads the target file(s), and attempts a dry-run apply.
+ * Removes patches that fail validation. Returns the filenames of valid patches.
+ */
+export async function validatePatches(skillsDir, config) {
+    let entries;
+    try {
+        entries = await fs.readdir(skillsDir);
+    }
+    catch {
+        return [];
+    }
+    const patchFiles = entries.filter((e) => e.endsWith('.patch'));
+    const validPatches = [];
+    for (const patchFile of patchFiles) {
+        const patchPath = path.join(skillsDir, patchFile);
+        let valid = true;
+        let reason = '';
+        try {
+            const patchContent = await fs.readFile(patchPath, 'utf-8');
+            const parsedPatches = Diff.parsePatch(patchContent);
+            if (!hasParsedPatchHunks(parsedPatches)) {
+                valid = false;
+                reason = 'no hunks found in patch';
+            }
+            else {
+                const applied = await applyParsedSkillPatches(parsedPatches, config);
+                if (!applied.success) {
+                    valid = false;
+                    switch (applied.reason) {
+                        case 'missingTargetPath':
+                            reason = 'missing target file path in patch header';
+                            break;
+                        case 'invalidPatchHeaders':
+                            reason = 'invalid diff headers';
+                            break;
+                        case 'outsideAllowedRoots':
+                            reason = `target file is outside skill roots: ${applied.targetPath}`;
+                            break;
+                        case 'newFileAlreadyExists':
+                            reason = `new file target already exists: ${applied.targetPath}`;
+                            break;
+                        case 'targetNotFound':
+                            reason = `target file not found: ${applied.targetPath}`;
+                            break;
+                        case 'doesNotApply':
+                            reason = `patch does not apply cleanly to ${applied.targetPath}`;
+                            break;
+                        default:
+                            reason = 'unknown patch validation failure';
+                            break;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            valid = false;
+            reason = `failed to read or parse patch: ${err}`;
+        }
+        if (valid) {
+            validPatches.push(patchFile);
+            debugLogger.log(`[MemoryService] Patch validated: ${patchFile}`);
+        }
+        else {
+            debugLogger.warn(`[MemoryService] Removing invalid patch ${patchFile}: ${reason}`);
+            try {
+                await fs.unlink(patchPath);
+            }
+            catch {
+                // Best-effort cleanup
+            }
+        }
+    }
+    return validPatches;
+}
 /**
  * Main entry point for the skill extraction background task.
  * Designed to be called fire-and-forget on session startup.
@@ -420,18 +672,28 @@ export async function startMemoryService(config) {
         debugLogger.log(`[MemoryService] State loaded: ${previousRuns} previous run(s), ${previouslyProcessed} session(s) already processed`);
         // Build session index: all eligible sessions with summaries + file paths.
         // The agent decides which to read in full via read_file.
-        const { sessionIndex, newSessionIds } = await buildSessionIndex(chatsDir, state);
+        const { sessionIndex, newSessionIds, candidateSessions } = await buildSessionIndex(chatsDir, state);
         const totalInIndex = sessionIndex ? sessionIndex.split('\n').length : 0;
-        debugLogger.log(`[MemoryService] Session scan: ${totalInIndex} eligible session(s) found, ${newSessionIds.length} new`);
+        debugLogger.log(`[MemoryService] Session scan: ${totalInIndex} indexed session(s), ${candidateSessions.length} surfaced as new candidates`);
         if (newSessionIds.length === 0) {
             debugLogger.log('[MemoryService] Skipped: no new sessions to process');
             return;
         }
         // Snapshot existing skill directories before extraction
         const skillsBefore = new Set();
+        const patchContentsBefore = new Map();
         try {
             const entries = await fs.readdir(skillsDir);
             for (const e of entries) {
+                if (e.endsWith('.patch')) {
+                    try {
+                        patchContentsBefore.set(e, await fs.readFile(path.join(skillsDir, e), 'utf-8'));
+                    }
+                    catch {
+                        // Ignore unreadable existing patches.
+                    }
+                    continue;
+                }
                 skillsBefore.add(e);
             }
         }
@@ -453,8 +715,42 @@ export async function startMemoryService(config) {
             modelConfig: agentDefinition.modelConfig,
         });
         debugLogger.log(`[MemoryService] Starting extraction agent (model: ${agentDefinition.modelConfig.model}, maxTurns: 30, maxTime: 30min)`);
+        const candidateSessionsByPath = new Map(candidateSessions.map((session) => [
+            path.resolve(session.filePath),
+            session,
+        ]));
+        const processedSessionKeys = new Set();
+        const pendingReadFileSessions = new Map();
         // Create and run the extraction agent
-        const executor = await LocalAgentExecutor.create(agentDefinition, context);
+        const executor = await LocalAgentExecutor.create(agentDefinition, context, (activity) => {
+            const readFileCallId = getReadFileStartCallId(activity);
+            if (readFileCallId) {
+                const resolvedPath = getResolvedReadFilePath(config, activity);
+                if (!resolvedPath) {
+                    return;
+                }
+                const session = candidateSessionsByPath.get(resolvedPath);
+                if (!session) {
+                    return;
+                }
+                pendingReadFileSessions.set(readFileCallId, getSessionVersionKey(session));
+                return;
+            }
+            const completedReadFileCallId = getCompletedReadFileCallId(activity);
+            if (completedReadFileCallId) {
+                const sessionKey = pendingReadFileSessions.get(completedReadFileCallId);
+                if (!sessionKey) {
+                    return;
+                }
+                processedSessionKeys.add(sessionKey);
+                pendingReadFileSessions.delete(completedReadFileCallId);
+                return;
+            }
+            const failedReadFileCallId = getFailedReadFileCallId(activity);
+            if (failedReadFileCallId) {
+                pendingReadFileSessions.delete(failedReadFileCallId);
+            }
+        });
         await executor.run({ request: 'Extract skills from the provided sessions.' }, abortController.signal);
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         // Diff skills directory to find newly created skills
@@ -462,7 +758,7 @@ export async function startMemoryService(config) {
         try {
             const entriesAfter = await fs.readdir(skillsDir);
             for (const e of entriesAfter) {
-                if (!skillsBefore.has(e)) {
+                if (!skillsBefore.has(e) && !e.endsWith('.patch')) {
                     skillsCreated.push(e);
                 }
             }
@@ -470,21 +766,66 @@ export async function startMemoryService(config) {
         catch {
             // Skills dir read failed
         }
+        // Validate any .patch files the agent generated
+        const validPatches = await validatePatches(skillsDir, config);
+        const patchesCreatedThisRun = [];
+        for (const patchFile of validPatches) {
+            const patchPath = path.join(skillsDir, patchFile);
+            let currentContent;
+            try {
+                currentContent = await fs.readFile(patchPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            if (patchContentsBefore.get(patchFile) !== currentContent) {
+                patchesCreatedThisRun.push(patchFile);
+            }
+        }
+        if (validPatches.length > 0) {
+            debugLogger.log(`[MemoryService] ${validPatches.length} valid patch(es) currently in inbox; ${patchesCreatedThisRun.length} created or updated this run`);
+        }
+        const processedSessions = candidateSessions
+            .filter((session) => processedSessionKeys.has(getSessionVersionKey(session)))
+            .map((session) => ({
+            sessionId: session.sessionId,
+            lastUpdated: session.lastUpdated,
+        }));
         // Record the run with full metadata
         const run = {
             runAt: new Date().toISOString(),
-            sessionIds: newSessionIds,
+            sessionIds: processedSessions.map((session) => session.sessionId),
+            candidateSessions: candidateSessions.map((session) => ({
+                sessionId: session.sessionId,
+                lastUpdated: session.lastUpdated,
+            })),
+            processedSessions,
             skillsCreated,
         };
         const updatedState = {
             runs: [...state.runs, run],
         };
         await writeExtractionState(statePath, updatedState);
-        if (skillsCreated.length > 0) {
-            debugLogger.log(`[MemoryService] Completed in ${elapsed}s. Created ${skillsCreated.length} skill(s): ${skillsCreated.join(', ')}`);
+        if (skillsCreated.length > 0 || patchesCreatedThisRun.length > 0) {
+            const completionParts = [];
+            if (skillsCreated.length > 0) {
+                completionParts.push(`created ${skillsCreated.length} skill(s): ${skillsCreated.join(', ')}`);
+            }
+            if (patchesCreatedThisRun.length > 0) {
+                completionParts.push(`prepared ${patchesCreatedThisRun.length} patch(es): ${patchesCreatedThisRun.join(', ')}`);
+            }
+            debugLogger.log(`[MemoryService] Completed in ${elapsed}s. ${completionParts.join('; ')} (read ${processedSessions.length}/${candidateSessions.length} surfaced session(s))`);
+            const feedbackParts = [];
+            if (skillsCreated.length > 0) {
+                feedbackParts.push(`${skillsCreated.length} new skill${skillsCreated.length > 1 ? 's' : ''} extracted from past sessions: ${skillsCreated.join(', ')}`);
+            }
+            if (patchesCreatedThisRun.length > 0) {
+                feedbackParts.push(`${patchesCreatedThisRun.length} skill update${patchesCreatedThisRun.length > 1 ? 's' : ''} extracted from past sessions`);
+            }
+            coreEvents.emitFeedback('info', `${feedbackParts.join('. ')}. Use /memory inbox to review.`);
         }
         else {
-            debugLogger.log(`[MemoryService] Completed in ${elapsed}s. No new skills created (processed ${newSessionIds.length} session(s))`);
+            debugLogger.log(`[MemoryService] Completed in ${elapsed}s. No new skills or patches created (read ${processedSessions.length}/${candidateSessions.length} surfaced session(s))`);
         }
     }
     catch (error) {