openclaw-topic-shift-reset 0.4.2 → 0.4.4

package/README.md

@@ -147,10 +147,13 @@ All plugin logs are prefixed with `topic-shift-reset:`.
   No embedding backend is available; lexical signals only.
 - `restored state sessions=<n> rotations=<n>`
   Persisted runtime state restored at startup.
+- `orphan-recovery recovered=<n> store=<...>`
+  Re-linked legacy orphan transcript files (`*.jsonl`) back into session-store entries.
 - `would-rotate source=<user|agent> reason=<...> session=<...> ...`
   Dry-run rotation decision; no session mutation is written.
-- `rotated source=<user|agent> reason=<...> session=<...> ... handoff=<0|1>`
+- `rotated source=<user|agent> reason=<...> session=<...> ... handoff=<0|1> archived=<0|1>`
   Rotation executed (new `sessionId` written). `handoff=1` means handoff context was enqueued.
+  `archived=1` means the previous transcript file was archived as `.reset.<timestamp>`.
 
 ### Debug (`debug: true`)
 
@@ -183,6 +186,10 @@ All plugin logs are prefixed with `topic-shift-reset:`.
   Tail read optimization fell back to a full transcript read.
 - `handoff read failed file=<...> err=<...>`
   Could not read prior session transcript for handoff injection.
+- `reset archive failed file=<...> err=<...>`
+  Could not archive the prior session transcript after rotation.
+- `orphan-recovery failed store=<...> err=<...>`
+  Legacy orphan recovery scan failed for this session store.
 - `persistence disabled (state path): <err>`
   Plugin could not resolve state path; persistence is disabled.
 - `state flush failed err=<...>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-topic-shift-reset",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "OpenClaw plugin that detects topic shifts and starts a fresh session automatically.",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -1252,8 +1252,9 @@ function classifyMessage(params: {
   now: number;
 }): ClassificationDecision {
   const { cfg, state, now } = params;
+  const hasSimilarity = params.usedEmbedding && typeof params.similarity === "number";
   const score =
-    params.usedEmbedding && typeof params.similarity === "number"
+    hasSimilarity
       ? 0.7 * (1 - params.similarity) +
         0.15 * params.lexical.lexicalDistance +
         0.15 * params.lexical.novelty
@@ -1281,21 +1282,25 @@ function classifyMessage(params: {
     return { kind: "stable", metrics, reason: "cooldown" };
   }
 
+  const lexicalHardSignal =
+    params.lexical.score >= cfg.hardScoreThreshold ||
+    (params.lexical.novelty >= cfg.hardNoveltyThreshold &&
+      params.lexical.lexicalDistance >= 0.65);
   const hardSignal =
-    score >= cfg.hardScoreThreshold ||
-    (params.usedEmbedding && typeof params.similarity === "number"
-      ? params.similarity <= cfg.hardSimilarityThreshold &&
-        params.lexical.novelty >= cfg.hardNoveltyThreshold
-      : params.lexical.novelty >= cfg.hardNoveltyThreshold &&
-        params.lexical.lexicalDistance >= 0.65);
+    hasSimilarity &&
+    (score >= cfg.hardScoreThreshold ||
+      (params.similarity <= cfg.hardSimilarityThreshold &&
+        params.lexical.novelty >= cfg.hardNoveltyThreshold));
 
   if (hardSignal) {
     return { kind: "rotate-hard", metrics, reason: "hard-threshold" };
   }
 
+  const forceSoftPathFromLexicalHard = !hasSimilarity && lexicalHardSignal;
   const softSignal =
+    forceSoftPathFromLexicalHard ||
     score >= cfg.softScoreThreshold ||
-    (params.usedEmbedding && typeof params.similarity === "number"
+    (hasSimilarity
       ? params.similarity <= cfg.softSimilarityThreshold &&
         params.lexical.novelty >= cfg.softNoveltyThreshold
       : params.lexical.novelty >= cfg.softNoveltyThreshold &&
@@ -1359,6 +1364,132 @@ function resolveSessionFilePathFromEntry(params: {
   return path.resolve(sessionsDir, `${sessionId}.jsonl`);
 }
 
+function formatSessionArchiveTimestamp(nowMs = Date.now()): string {
+  return new Date(nowMs).toISOString().replaceAll(":", "-");
+}
+
+async function archivePreviousSessionTranscript(params: {
+  storePath: string;
+  previousEntry?: SessionEntryLike;
+  logger: OpenClawPluginApi["logger"];
+}): Promise<string | null> {
+  const sessionFile = resolveSessionFilePathFromEntry({
+    storePath: params.storePath,
+    entry: params.previousEntry,
+  });
+  if (!sessionFile) {
+    return null;
+  }
+
+  const archivedPath = `${sessionFile}.reset.${formatSessionArchiveTimestamp()}`;
+  try {
+    await fs.rename(sessionFile, archivedPath);
+    return archivedPath;
+  } catch (error) {
+    const code =
+      error && typeof error === "object" && "code" in error ? String((error as { code?: unknown }).code) : "";
+    if (code === "ENOENT") {
+      return null;
+    }
+    params.logger.warn(`topic-shift-reset: reset archive failed file=${sessionFile} err=${String(error)}`);
+    return null;
+  }
+}
+
+function normalizeRecoveryAgentId(agentId?: string): string {
+  const trimmed = typeof agentId === "string" ? agentId.trim() : "";
+  if (!trimmed) {
+    return "main";
+  }
+  return trimmed.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+
+async function recoverLegacyOrphanedSessionEntries(params: {
+  storePath: string;
+  agentId?: string;
+  logger: OpenClawPluginApi["logger"];
+}): Promise<number> {
+  let recovered = 0;
+  await withFileLock(params.storePath, LOCK_OPTIONS, async () => {
+    const loaded = await readJsonFileWithFallback<Record<string, SessionEntryLike>>(params.storePath, {});
+    const store = loaded.value;
+    const sessionsDir = path.dirname(params.storePath);
+    const entries = await fs.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
+    if (entries.length === 0) {
+      return;
+    }
+
+    const referencedSessionIds = new Set<string>();
+    const referencedFiles = new Set<string>();
+    for (const entry of Object.values(store)) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const sessionId = typeof entry.sessionId === "string" ? entry.sessionId.trim() : "";
+      if (sessionId) {
+        referencedSessionIds.add(sessionId);
+      }
+      const sessionFile = resolveSessionFilePathFromEntry({
+        storePath: params.storePath,
+        entry,
+      });
+      if (sessionFile) {
+        referencedFiles.add(path.resolve(sessionFile));
+      }
+    }
+
+    let changed = false;
+    const recoveryAgentId = normalizeRecoveryAgentId(params.agentId);
+    for (const candidate of entries) {
+      if (!candidate.isFile()) {
+        continue;
+      }
+      const fileName = candidate.name;
+      if (!fileName.endsWith(".jsonl")) {
+        continue;
+      }
+      const fullPath = path.resolve(sessionsDir, fileName);
+      if (referencedFiles.has(fullPath)) {
+        continue;
+      }
+
+      const sessionId = fileName.slice(0, -".jsonl".length).trim();
+      if (!sessionId || referencedSessionIds.has(sessionId)) {
+        continue;
+      }
+
+      const stat = await fs.stat(fullPath).catch(() => null);
+      if (!stat || !stat.isFile()) {
+        continue;
+      }
+
+      const baseKey = `agent:${recoveryAgentId}:recovered:${sessionId}`;
+      let recoveryKey = baseKey;
+      let suffix = 2;
+      while (Object.prototype.hasOwnProperty.call(store, recoveryKey)) {
+        recoveryKey = `${baseKey}:${suffix}`;
+        suffix += 1;
+      }
+      store[recoveryKey] = {
+        sessionId,
+        updatedAt: Math.max(0, Math.floor(stat.mtimeMs)),
+        sessionFile: fileName,
+        systemSent: false,
+        abortedLastRun: false,
+      };
+      referencedSessionIds.add(sessionId);
+      referencedFiles.add(fullPath);
+      recovered += 1;
+      changed = true;
+    }
+
+    if (changed) {
+      await writeJsonFileAtomically(params.storePath, store);
+    }
+  });
+  return recovered;
+}
+
 function parseTranscriptTailLines(lines: string[], takeLast: number): TranscriptMessage[] {
   const messages: TranscriptMessage[] = [];
   for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -1658,6 +1789,11 @@ async function rotateSessionEntry(params: {
       contextKey: `topic-shift-reset:${params.contentHash}`,
     });
   }
+  const archivedTranscript = await archivePreviousSessionTranscript({
+    storePath,
+    previousEntry,
+    logger: params.api.logger,
+  });
 
   params.state.lastResetAt = Date.now();
   params.state.pendingSoftSignals = 0;
@@ -1676,6 +1812,7 @@ async function rotateSessionEntry(params: {
       `lex=${params.metrics.lexicalDistance.toFixed(3)}`,
       `sim=${typeof params.metrics.similarity === "number" ? params.metrics.similarity.toFixed(3) : "n/a"}`,
       `handoff=${handoff ? "1" : "0"}`,
+      `archived=${archivedTranscript ? "1" : "0"}`,
     ].join(" "),
   );
 
@@ -1691,6 +1828,7 @@ export default function register(api: OpenClawPluginApi): void {
   const pendingSoftSuspectSteeringBySession = new Map<string, number>();
   const awaitingSoftSuspectReplyBySession = new Map<string, number>();
   const sessionWorkQueue = new Map<string, Promise<unknown>>();
+  const orphanRecoveryByStorePath = new Map<string, Promise<void>>();
 
   const clearSoftSuspectSteerState = (sessionKey: string) => {
     pendingSoftSuspectSteeringBySession.delete(sessionKey);
@@ -1915,6 +2053,42 @@ export default function register(api: OpenClawPluginApi): void {
       return;
     }
 
+    const ensureLegacyOrphanRecovery = async () => {
+      if (cfg.dryRun) {
+        return;
+      }
+      const storePath = api.runtime.channel.session.resolveStorePath(api.config.session?.store, {
+        agentId: params.agentId,
+      });
+      const normalizedStorePath = path.resolve(storePath);
+      const existing = orphanRecoveryByStorePath.get(normalizedStorePath);
+      if (existing) {
+        await existing;
+        return;
+      }
+      const pending = (async () => {
+        try {
+          const recovered = await recoverLegacyOrphanedSessionEntries({
+            storePath: normalizedStorePath,
+            agentId: params.agentId,
+            logger: api.logger,
+          });
+          if (recovered > 0) {
+            api.logger.info(
+              `topic-shift-reset: orphan-recovery recovered=${recovered} store=${normalizedStorePath}`,
+            );
+          }
+        } catch (error) {
+          api.logger.warn(
+            `topic-shift-reset: orphan-recovery failed store=${normalizedStorePath} err=${String(error)}`,
+          );
+        }
+      })();
+      orphanRecoveryByStorePath.set(normalizedStorePath, pending);
+      await pending;
+    };
+    await ensureLegacyOrphanRecovery();
+
     const rawText = params.text.trim();
     const text = cfg.stripEnvelope ? stripClassifierEnvelope(rawText, cfg.stripRules) : rawText;
     if (!text || text.startsWith("/")) {