@syntesseraai/opencode-feature-factory 0.3.3 → 0.3.4

package/dist/local-recall/daemon.js

@@ -23,32 +23,51 @@ import { getMemoriesDir, storeMemories } from './memory-service.js';
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function toProcessedFailureEntry(failure, failureMessage) {
+    switch (failure.scope) {
+        case 'project':
+            return {
+                kind: 'failure',
+                scope: 'project',
+                processedAt: Date.now(),
+                failure: failureMessage,
+                directory: failure.directory,
+            };
+        case 'session':
+            return {
+                kind: 'failure',
+                scope: 'session',
+                processedAt: Date.now(),
+                failure: failureMessage,
+                sessionID: failure.sessionID,
+            };
+        case 'extraction':
+            return {
+                kind: 'failure',
+                scope: 'extraction',
+                processedAt: Date.now(),
+                failure: failureMessage,
+            };
+    }
+}
 function recordFailure(stats, failure) {
     let message;
-    let rawError;
     switch (failure.scope) {
         case 'project':
             message = `No OpenCode project found for directory: ${failure.directory}`;
             break;
         case 'message':
             message = `Error processing message ${failure.messageID}: ${getErrorMessage(failure.error)}`;
-            rawError = failure.error;
             break;
         case 'session':
             message = `Error processing session ${failure.sessionID}: ${getErrorMessage(failure.error)}`;
-            rawError = failure.error;
             break;
         case 'extraction':
             message = `Extraction failed: ${getErrorMessage(failure.error)}`;
-            rawError = failure.error;
             break;
     }
     stats.errors.push(message);
-    if (rawError !== undefined) {
-        console.error('[local-recall-daemon]', message, rawError);
-        return;
-    }
-    console.error('[local-recall-daemon]', message);
+    return message;
 }
 // ────────────────────────────────────────────────────────────
 // Helpers
@@ -99,7 +118,14 @@ export async function runExtraction(directory) {
         // Find project for this directory
         const project = await findProject(directory);
         if (!project) {
-            recordFailure(stats, { scope: 'project', directory });
+            const failure = { scope: 'project', directory };
+            const failureMessage = recordFailure(stats, failure);
+            try {
+                await markProcessed(directory, [toProcessedFailureEntry(failure, failureMessage)]);
+            }
+            catch (persistErr) {
+                stats.errors.push(`Failed to persist processing failure: ${getErrorMessage(persistErr)}`);
+            }
             return stats;
         }
         // Ensure local-recall directories exist
@@ -203,11 +229,13 @@ export async function runExtraction(directory) {
                 }
             }
             catch (err) {
-                recordFailure(stats, {
+                const failure = {
                     scope: 'session',
                     sessionID: session.id,
                     error: err,
-                });
+                };
+                const failureMessage = recordFailure(stats, failure);
+                newProcessedEntries.push(toProcessedFailureEntry(failure, failureMessage));
             }
         }
         // Batch store all new memories
@@ -221,7 +249,14 @@ export async function runExtraction(directory) {
         }
     }
     catch (err) {
-        recordFailure(stats, { scope: 'extraction', error: err });
+        const failure = { scope: 'extraction', error: err };
+        const failureMessage = recordFailure(stats, failure);
+        try {
+            await markProcessed(directory, [toProcessedFailureEntry(failure, failureMessage)]);
+        }
+        catch (persistErr) {
+            stats.errors.push(`Failed to persist processing failure: ${getErrorMessage(persistErr)}`);
+        }
     }
     return stats;
 }

package/dist/local-recall/processed-log.js

@@ -11,6 +11,9 @@
 import { createHash } from 'node:crypto';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+function isProcessedMessageEntry(entry) {
+    return 'messageID' in entry && 'contentHash' in entry;
+}
 function getLogPath(directory) {
     return join(directory, 'ff-memories', 'processed.json');
 }
@@ -48,7 +51,7 @@ export async function readProcessedLog(directory) {
  */
 export async function isProcessed(directory, messageID) {
     const log = await readProcessedLog(directory);
-    return log.some((entry) => entry.messageID === messageID);
+    return log.some((entry) => isProcessedMessageEntry(entry) && entry.messageID === messageID);
 }
 /**
  * Check if a content hash has already been processed.
@@ -56,7 +59,7 @@ export async function isProcessed(directory, messageID) {
  */
 export async function isContentProcessed(directory, hash) {
     const log = await readProcessedLog(directory);
-    return log.some((entry) => entry.contentHash === hash);
+    return log.some((entry) => isProcessedMessageEntry(entry) && entry.contentHash === hash);
 }
 /**
  * Mark messages as processed by appending entries to the log.
@@ -72,11 +75,11 @@ export async function markProcessed(directory, entries) {
  * Get the set of already-processed message IDs for fast lookup.
  */
 export function getProcessedMessageIDs(log) {
-    return new Set(log.map((e) => e.messageID));
+    return new Set(log.filter(isProcessedMessageEntry).map((e) => e.messageID));
 }
 /**
  * Get the set of already-processed content hashes for fast lookup.
  */
 export function getProcessedHashes(log) {
-    return new Set(log.map((e) => e.contentHash));
+    return new Set(log.filter(isProcessedMessageEntry).map((e) => e.contentHash));
 }

package/dist/local-recall/storage-reader.js

@@ -45,6 +45,10 @@ async function dirExists(dirPath) {
         return false;
     }
 }
+function getPartStartTime(part) {
+    const start = part.time?.start;
+    return typeof start === 'number' ? start : Number.POSITIVE_INFINITY;
+}
 // ── Project Reader ──────────────────────────────────────────────
 /**
  * Find the project record whose worktree matches `directory`.
@@ -131,7 +135,13 @@ export async function listParts(messageID) {
     if (!(await dirExists(partDir)))
         return [];
     const parts = await readAllJsonInDir(partDir);
-    return parts.sort((a, b) => a.time.start - b.time.start);
+    return parts.sort((a, b) => {
+        const timeDelta = getPartStartTime(a) - getPartStartTime(b);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        return a.id.localeCompare(b.id);
+    });
 }
 /**
  * Get a single part by ID.

package/dist/local-recall/types.d.ts

@@ -54,10 +54,10 @@ export interface OCPart {
     messageID: string;
     type: string;
     text?: string;
-    synthetic: boolean;
-    time: {
-        start: number;
-        end: number;
+    synthetic?: boolean;
+    time?: {
+        start?: number;
+        end?: number;
     };
 }
 /** A memory extracted from a conversation turn */
@@ -119,24 +119,34 @@ export interface ExtractionResult {
     /** Where the extraction came from — used to generate logical IDs */
     source: 'session' | 'thinking';
 }
-interface ProcessedEntryBase {
+interface ProcessedMessageEntryBase {
     messageID: string;
     processedAt: number;
     /** SHA-256 hex hash of the concatenated extracted bodies for content-level idempotency */
     contentHash: string;
 }
 /** Tracks which messages have already been processed */
-export type ProcessedEntry = (ProcessedEntryBase & {
+export type ProcessedMessageEntry = (ProcessedMessageEntryBase & {
     status: 'success';
     memoriesCreated: number;
     failure?: undefined;
-}) | (ProcessedEntryBase & {
+}) | (ProcessedMessageEntryBase & {
     status: 'failed';
     memoriesCreated: 0;
     failure: string;
-}) | (ProcessedEntryBase & {
+}) | (ProcessedMessageEntryBase & {
     status?: undefined;
     memoriesCreated: number;
     failure?: undefined;
 });
+/** Persistent daemon-level failures that are not tied to a specific message record. */
+export type ProcessedFailureEntry = {
+    kind: 'failure';
+    scope: 'project' | 'session' | 'extraction';
+    processedAt: number;
+    failure: string;
+    directory?: string;
+    sessionID?: string;
+};
+export type ProcessedEntry = ProcessedMessageEntry | ProcessedFailureEntry;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",