openclaw-topic-shift-reset 0.3.0 → 0.4.1

package/README.md

@@ -2,6 +2,8 @@
 
 OpenClaw plugin that detects topic shifts and rotates to a fresh session automatically.
 
+Classifier input sources: inbound user message text (`message_received`) and successful outbound agent message text (`message_sent`) only. It does not classify `before_model_resolve` prompt wrappers.
+
 ## Why this plugin exists
 
 OpenClaw builds each model call with the current prompt plus session history. As one session accumulates mixed topics, prompts get larger, token usage grows, and context-overflow/compaction pressure increases.
@@ -45,6 +47,7 @@ Add this plugin entry in `~/.openclaw/openclaw.json` (or merge into your existin
           },
           "softSuspect": {
             "action": "ask",
+            "mode": "strict",
             "ttlSeconds": 120
           },
           "dryRun": false,
@@ -114,6 +117,7 @@ When the classifier sees a soft topic-shift signal (`suspect`) but not enough co
 {
   "softSuspect": {
     "action": "ask",
+    "mode": "strict",
     "prompt": "Potential topic shift detected. Ask one short clarification question to confirm the user's new goal before proceeding.",
     "ttlSeconds": 120
   }
@@ -121,6 +125,7 @@ When the classifier sees a soft topic-shift signal (`suspect`) but not enough co
 ```
 
 - `action`: `ask` (default) or `none`.
+- `mode`: `strict` (default, require clarification turn before soft-confirm reset) or `best_effort` (legacy timing-based behavior).
 - `prompt`: optional custom steer text.
 - `ttlSeconds`: max age before a pending steer expires.
 
@@ -130,6 +135,67 @@ When the classifier sees a soft topic-shift signal (`suspect`) but not enough co
 openclaw logs --follow --plain | rg topic-shift-reset
 ```
 
+## Log reference
+
+All plugin logs are prefixed with `topic-shift-reset:`.
+
+### Info
+
+- `embedding backend <name>`
+  Embeddings are active (`openai:*` or `ollama:*` backend).
+- `embedding backend unavailable, using lexical-only mode`
+  No embedding backend is available; lexical signals only.
+- `restored state sessions=<n> rotations=<n>`
+  Persisted runtime state restored at startup.
+- `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>`
+  Rotation executed (new `sessionId` written). `handoff=1` means handoff context was enqueued.
+
+### Debug (`debug: true`)
+
+- `classify source=<...> kind=<warmup|stable|suspect|rotate-hard|rotate-soft> reason=<...> ...`
+  Full classifier output and metrics for a processed message.
+- `suspect-queued session=<...>`
+  Soft-suspect state queued for clarification steering.
+- `ask-injected session=<...>`
+  Clarification steer was injected into prompt build for this session.
+- `ask-resolved user-reply session=<...>`
+  A new user reply arrived after the injected clarification turn.
+- `ask-blocked-waiting-injection session=<...>`
+  Strict mode prevented soft-confirm reset until clarification steer is injected.
+- `skip-internal-provider source=<...> provider=<...> session=<...>`
+  Skipped event from internal/non-user provider (for example cron/system paths).
+- `skip-low-signal source=<...> session=<...> chars=<n> tokens=<n>`
+  Skipped message because it did not meet minimum signal thresholds.
+- `user-route-skip channel=<...> peer=<...> err=<...>`
+  User-message route resolution failed, so the inbound event was ignored.
+- `agent-route-skip channel=<...> peer=<...> err=<...>`
+  Agent-message route resolution failed, so the outbound event was ignored.
+- `state-flushed reason=<scheduled|urgent|gateway-stop> sessions=<n> rotations=<n>`
+  In-memory classifier state flushed to persistence storage.
+
+### Warn
+
+- `rotate failed no-session-entry session=<...>`
+  Rotation was requested but no matching session entry was found to mutate.
+- `handoff tail fallback full-read file=<...>`
+  Tail read optimization fell back to a full transcript read.
+- `handoff read failed file=<...> err=<...>`
+  Could not read prior session transcript for handoff injection.
+- `persistence disabled (state path): <err>`
+  Plugin could not resolve state path; persistence is disabled.
+- `state flush failed err=<...>`
+  Failed to write persistent state.
+- `state restore failed err=<...>`
+  Failed to read/parse persistent state.
+- `state version mismatch expected=<...> got=<...>; ignoring persisted state`
+  Stored persistence schema version differs; old state is ignored.
+- `embedding backend init failed: <err>`
+  Embedding backend initialization failed at startup.
+- `embeddings error backend=<name> err=<...>`
+  Runtime embedding request failed for a message; processing continues.
+
 ## Advanced tuning
 
 Use `config.advanced` only if needed. Full reference:
@@ -155,4 +221,4 @@ No build step is required. OpenClaw loads `src/index.ts` via jiti.
 
 ## Known tradeoff (plugin-only)
 
-This plugin improves timing with fast path + fallback, but cannot guarantee 100% that the triggering message becomes the first persisted message of the new session without core pre-session hooks.
+This plugin cannot guarantee 100% that the triggering message becomes the first persisted message of the new session because resets happen in runtime hooks and provider pipelines vary.

package/docs/configuration.md

@@ -19,6 +19,7 @@ This plugin now accepts one canonical key per concept:
   },
   "softSuspect": {
     "action": "ask",
+    "mode": "strict",
     "ttlSeconds": 120
   },
   "dryRun": false,
@@ -28,6 +29,9 @@ This plugin now accepts one canonical key per concept:
 
 ## Public options
 
+Classifier inputs are limited to inbound user message text and successful outbound agent message text.
+With `softSuspect.mode: "strict"` (default), a soft-confirm reset is blocked until a clarification steer is injected and a subsequent user reply is observed.
+
 - `enabled`: plugin on/off.
 - `preset`: `conservative | balanced | aggressive`.
 - `embedding.provider`: `auto | openai | ollama | none`.
@@ -39,6 +43,7 @@ This plugin now accepts one canonical key per concept:
 - `handoff.lastN`: number of transcript messages to include in handoff.
 - `handoff.maxChars`: per-message truncation cap in handoff text.
 - `softSuspect.action`: `ask | none`.
+- `softSuspect.mode`: `strict | best_effort`.
 - `softSuspect.prompt`: optional steer text injected on soft-suspect.
 - `softSuspect.ttlSeconds`: expiry for pending soft-suspect steer.
 - `dryRun`: logs would-rotate events without session resets.
@@ -69,6 +74,7 @@ This plugin now accepts one canonical key per concept:
 - `handoff.lastN`: `6`
 - `handoff.maxChars`: `220`
 - `softSuspect.action`: `ask`
+- `softSuspect.mode`: `strict`
 - `softSuspect.ttlSeconds`: `120`
 - `advanced.minSignalChars`: `20`
 - `advanced.minSignalTokenCount`: `3`
@@ -128,7 +134,7 @@ Advanced keys:
 `ignoredProviders` expects canonical provider IDs:
 
 - `telegram`, `whatsapp`, `signal`, `discord`, `slack`, `matrix`, `msteams`, `imessage`, `web`, `voice`
-- model/provider IDs like `openai`, `anthropic`, `ollama` (for fallback hook contexts)
+- internal/system-style providers like `cron-event`, `heartbeat`, `exec-event`
 
 ## Migration note
 
@@ -145,14 +151,14 @@ Legacy alias keys are not supported in this release. Config validation fails if
 Classifier runtime state is persisted automatically under the OpenClaw state directory (`plugins/<plugin-id>/runtime-state.v1.json`).
 
 - Persisted: per-session topic history, pending soft-signal windows, topic centroid, rotation dedupe map.
-- Not persisted: transient fast-event dedupe cache.
+- Not persisted: transient message-event dedupe cache.
 - No extra config is required.
 
 ## Log interpretation
 
 Classifier logs look like:
 
-`topic-shift-reset: classify source=<fast|fallback> kind=<...> reason=<...> ...`
+`topic-shift-reset: classify source=<user|agent> kind=<...> reason=<...> ...`
 
 Kinds:
 
@@ -167,4 +173,4 @@ Other lines:
 - `skip-low-signal`: message skipped by hard signal floor (`minSignalChars`/`minSignalTokenCount`).
 - `would-rotate`: `dryRun=true` synthetic rotate event (no reset mutation).
 - `rotated`: actual session rotation happened.
-- `classify` / `skip-low-signal` / `skip-cross-path-duplicate`: debug-level diagnostics (`debug=true`).
+- `classify` / `skip-low-signal` / `user-route-skip` / `agent-route-skip`: debug-level diagnostics (`debug=true`).

package/openclaw.plugin.json

@@ -73,6 +73,11 @@
             "enum": ["none", "ask"],
             "default": "ask"
           },
+          "mode": {
+            "type": "string",
+            "enum": ["strict", "best_effort"],
+            "default": "strict"
+          },
           "prompt": {
             "type": "string",
             "default": "Potential topic shift detected. Ask one short clarification question to confirm the user's new goal before proceeding."
@@ -268,7 +273,7 @@
     },
     "softSuspect": {
       "label": "Soft-Suspect Clarification",
-      "help": "When a soft topic-shift signal appears, optionally steer the model to ask one clarification question before proceeding."
+      "help": "strict = require one clarification turn before soft-confirm reset. best_effort = steer when possible."
     },
     "dryRun": {
       "label": "Dry Run",

package/package.json

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

package/src/index.ts

@@ -12,6 +12,7 @@ type PresetName = "conservative" | "balanced" | "aggressive";
 type EmbeddingProvider = "auto" | "none" | "openai" | "ollama";
 type HandoffMode = "none" | "summary" | "verbatim_last_n";
 type SoftSuspectAction = "none" | "ask";
+type SoftSuspectMode = "best_effort" | "strict";
 
 type EmbeddingConfig = {
   provider?: EmbeddingProvider;
@@ -29,6 +30,7 @@ type HandoffConfig = {
 
 type SoftSuspectConfig = {
   action?: SoftSuspectAction;
+  mode?: SoftSuspectMode;
   prompt?: string;
   ttlSeconds?: number;
 };
@@ -110,6 +112,7 @@ type ResolvedConfig = {
   };
   softSuspect: {
     action: SoftSuspectAction;
+    mode: SoftSuspectMode;
     prompt: string;
     ttlMs: number;
   };
@@ -211,6 +214,8 @@ type FastMessageEventLike = {
   metadata?: Record<string, unknown>;
 };
 
+type ClassificationSource = "user" | "agent";
+
 type TranscriptMessage = {
   role: string;
   text: string;
@@ -283,6 +288,7 @@ const DEFAULTS = {
   handoffLastN: 6,
   handoffMaxChars: 220,
   softSuspectAction: "ask" as SoftSuspectAction,
+  softSuspectMode: "strict" as SoftSuspectMode,
   softSuspectPrompt:
     "Potential topic shift detected. Ask one short clarification question to confirm the user's new goal before proceeding.",
   softSuspectTtlSeconds: 120,
@@ -320,10 +326,9 @@ const LOCK_OPTIONS = {
 
 const MAX_TRACKED_SESSIONS = 10_000;
 const STALE_SESSION_STATE_MS = 4 * 60 * 60 * 1000;
-const MAX_RECENT_FAST_EVENTS = 20_000;
-const FAST_EVENT_TTL_MS = 5 * 60 * 1000;
+const MAX_RECENT_MESSAGE_EVENTS = 20_000;
+const MESSAGE_EVENT_TTL_MS = 5 * 60 * 1000;
 const ROTATION_DEDUPE_MS = 25_000;
-const CROSS_PATH_DEDUPE_MS = 15_000;
 const PERSISTENCE_SCHEMA_VERSION = 1;
 const PERSISTENCE_FILE_NAME = "runtime-state.v1.json";
 const PERSISTENCE_FLUSH_DEBOUNCE_MS = 1_200;
@@ -407,6 +412,17 @@ function normalizeSoftSuspectAction(value: unknown): SoftSuspectAction {
   return DEFAULTS.softSuspectAction;
 }
 
+function normalizeSoftSuspectMode(value: unknown): SoftSuspectMode {
+  if (typeof value !== "string") {
+    return DEFAULTS.softSuspectMode;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "best_effort" || normalized === "strict") {
+    return normalized;
+  }
+  return DEFAULTS.softSuspectMode;
+}
+
 function compileRegexList(values: unknown, fallback: readonly string[]): RegExp[] {
   const source = Array.isArray(values) ? values : fallback;
   const out: RegExp[] = [];
@@ -789,6 +805,7 @@ function resolveConfig(raw: unknown): ResolvedConfig {
     },
     softSuspect: {
       action: normalizeSoftSuspectAction(softSuspect.action),
+      mode: normalizeSoftSuspectMode(softSuspect.mode),
       prompt:
         typeof softSuspect.prompt === "string" && softSuspect.prompt.trim()
           ? softSuspect.prompt.trim()
@@ -1556,40 +1573,12 @@ function pruneRecentMap(map: Map<string, number>, ttlMs: number, maxSize: number
   return changed;
 }
 
-function pruneRecentClassifiedMap(
-  map: Map<string, { at: number; source: "fast" | "fallback" }>,
-  ttlMs: number,
-  maxSize: number,
-): boolean {
-  let changed = false;
-  const now = Date.now();
-  for (const [key, value] of map) {
-    if (now - value.at > ttlMs) {
-      map.delete(key);
-      changed = true;
-    }
-  }
-  if (map.size <= maxSize) {
-    return changed;
-  }
-  const ordered = [...map.entries()].sort((a, b) => a[1].at - b[1].at);
-  const toDrop = map.size - maxSize;
-  for (let i = 0; i < toDrop; i += 1) {
-    const key = ordered[i]?.[0];
-    if (key) {
-      map.delete(key);
-      changed = true;
-    }
-  }
-  return changed;
-}
-
 async function rotateSessionEntry(params: {
   api: OpenClawPluginApi;
   cfg: ResolvedConfig;
   sessionKey: string;
   agentId?: string;
-  source: "fast" | "fallback";
+  source: ClassificationSource;
   reason: string;
   metrics: ClassifierMetrics;
   entry: HistoryEntry;
@@ -1694,15 +1683,18 @@ async function rotateSessionEntry(params: {
 export default function register(api: OpenClawPluginApi): void {
   const cfg = resolveConfig(api.pluginConfig);
   const sessionState = new Map<string, SessionState>();
-  const recentFastEvents = new Map<string, number>();
+  const recentUserEvents = new Map<string, number>();
+  const recentAgentEvents = new Map<string, number>();
   const recentRotationBySession = new Map<string, number>();
   const pendingSoftSuspectSteeringBySession = new Map<string, number>();
-  const recentClassifiedBySessionHash = new Map<
-    string,
-    { at: number; source: "fast" | "fallback" }
-  >();
+  const awaitingSoftSuspectReplyBySession = new Map<string, number>();
   const sessionWorkQueue = new Map<string, Promise<unknown>>();
 
+  const clearSoftSuspectSteerState = (sessionKey: string) => {
+    pendingSoftSuspectSteeringBySession.delete(sessionKey);
+    awaitingSoftSuspectReplyBySession.delete(sessionKey);
+  };
+
   const persistencePath = (() => {
     try {
       const stateDir = api.runtime.state.resolveStateDir();
@@ -1741,7 +1733,7 @@ export default function register(api: OpenClawPluginApi): void {
     persistenceFlushPromise = (async () => {
       const now = Date.now();
       pruneStateMaps(sessionState);
-      pruneRecentMap(recentRotationBySession, ROTATION_DEDUPE_MS * 3, MAX_RECENT_FAST_EVENTS);
+      pruneRecentMap(recentRotationBySession, ROTATION_DEDUPE_MS * 3, MAX_RECENT_MESSAGE_EVENTS);
 
       const payload: PersistedRuntimeState = {
         version: PERSISTENCE_SCHEMA_VERSION,
@@ -1866,7 +1858,7 @@ export default function register(api: OpenClawPluginApi): void {
         }
         recentRotationBySession.set(key, Math.floor(ts));
       }
-      pruneRecentMap(recentRotationBySession, ROTATION_DEDUPE_MS * 3, MAX_RECENT_FAST_EVENTS);
+      pruneRecentMap(recentRotationBySession, ROTATION_DEDUPE_MS * 3, MAX_RECENT_MESSAGE_EVENTS);
 
       api.logger.info(
         `topic-shift-reset: restored state sessions=${sessionState.size} rotations=${recentRotationBySession.size}`,
@@ -1893,7 +1885,7 @@ export default function register(api: OpenClawPluginApi): void {
   }
 
   const classifyAndMaybeRotateInner = async (params: {
-    source: "fast" | "fallback";
+    source: ClassificationSource;
     sessionKey: string;
     text: string;
     messageProvider?: string;
@@ -1944,31 +1936,10 @@ export default function register(api: OpenClawPluginApi): void {
     }
 
     const tokens = new Set(tokenList);
-
     const now = Date.now();
-    const contentHash = hashString(normalizeTextForHash(text));
-    const classifyDedupeKey = `${sessionKey}:${contentHash}`;
-    const recentCrossSourceClassification = recentClassifiedBySessionHash.get(classifyDedupeKey);
-    if (
-      recentCrossSourceClassification &&
-      recentCrossSourceClassification.source !== params.source &&
-      now - recentCrossSourceClassification.at < CROSS_PATH_DEDUPE_MS
-    ) {
-      if (cfg.debug) {
-        api.logger.debug(
-          [
-            `topic-shift-reset: skip-cross-path-duplicate`,
-            `session=${sessionKey}`,
-            `source=${params.source}`,
-            `prevSource=${recentCrossSourceClassification.source}`,
-          ].join(" "),
-        );
-      }
-      return;
-    }
-    recentClassifiedBySessionHash.set(classifyDedupeKey, { at: now, source: params.source });
-    pruneRecentClassifiedMap(recentClassifiedBySessionHash, CROSS_PATH_DEDUPE_MS * 3, MAX_RECENT_FAST_EVENTS);
+    const entry: HistoryEntry = { tokens, at: now };
 
+    const contentHash = hashString(normalizeTextForHash(text));
     const lastRotationAt = recentRotationBySession.get(`${sessionKey}:${contentHash}`);
     if (typeof lastRotationAt === "number" && now - lastRotationAt < ROTATION_DEDUPE_MS) {
       return;
@@ -1987,10 +1958,41 @@ export default function register(api: OpenClawPluginApi): void {
       } satisfies SessionState);
     state.lastSeenAt = now;
 
+    if (params.source === "agent") {
+      // Outbound agent text helps keep topic context fresh, but it should not
+      // advance soft-suspect confirmation state by itself.
+      state.history = trimHistory([...state.history, entry], cfg.historyWindow);
+      updateTopicCentroid(state, entry.embedding);
+      sessionState.set(sessionKey, state);
+      pruneStateMaps(sessionState);
+      schedulePersistentFlush(false);
+      return;
+    }
+
+    const pendingSoftSteerAt = pendingSoftSuspectSteeringBySession.get(sessionKey);
+    const pendingSoftSteerActive =
+      typeof pendingSoftSteerAt === "number" && now - pendingSoftSteerAt <= cfg.softSuspect.ttlMs;
+    if (typeof pendingSoftSteerAt === "number" && !pendingSoftSteerActive) {
+      pendingSoftSuspectSteeringBySession.delete(sessionKey);
+    }
+
+    const awaitingSoftReplyAt = awaitingSoftSuspectReplyBySession.get(sessionKey);
+    const awaitingSoftReplyActive =
+      typeof awaitingSoftReplyAt === "number" && now - awaitingSoftReplyAt <= cfg.softSuspect.ttlMs;
+    if (typeof awaitingSoftReplyAt === "number" && !awaitingSoftReplyActive) {
+      awaitingSoftSuspectReplyBySession.delete(sessionKey);
+    }
+    if (awaitingSoftReplyActive) {
+      awaitingSoftSuspectReplyBySession.delete(sessionKey);
+      if (cfg.debug) {
+        api.logger.debug(`topic-shift-reset: ask-resolved user-reply session=${sessionKey}`);
+      }
+    }
+
     const baselineTokens = unionTokens(state.history);
     const lexical = computeLexicalFeatures({
       cfg,
-      entry: { tokens, at: now },
+      entry,
       tokenList,
       baselineTokens,
     });
@@ -2021,12 +2023,14 @@ export default function register(api: OpenClawPluginApi): void {
       }
     }
 
-    const entry: HistoryEntry = { tokens, embedding, at: now };
+    if (Array.isArray(embedding) && embedding.length > 0) {
+      entry.embedding = embedding;
+    }
     const similarity =
       entry.embedding && state.topicCentroid
         ? cosineSimilarity(entry.embedding, state.topicCentroid)
         : undefined;
-    const decision = classifyMessage({
+    let decision = classifyMessage({
       cfg,
       state,
       baselineTokenCount: baselineTokens.size,
@@ -2036,6 +2040,22 @@ export default function register(api: OpenClawPluginApi): void {
       now,
     });
 
+    if (
+      cfg.softSuspect.action === "ask" &&
+      cfg.softSuspect.mode === "strict" &&
+      pendingSoftSteerActive &&
+      decision.kind === "rotate-soft"
+    ) {
+      if (cfg.debug) {
+        api.logger.debug(`topic-shift-reset: ask-blocked-waiting-injection session=${sessionKey}`);
+      }
+      decision = {
+        kind: "suspect",
+        reason: "soft-suspect-awaiting-ask",
+        metrics: decision.metrics,
+      };
+    }
+
     if (cfg.debug) {
       api.logger.debug(
         [
@@ -2057,7 +2077,7 @@ export default function register(api: OpenClawPluginApi): void {
     }
 
     if (decision.kind === "warmup") {
-      pendingSoftSuspectSteeringBySession.delete(sessionKey);
+      clearSoftSuspectSteerState(sessionKey);
       state.pendingSoftSignals = 0;
       state.pendingEntries = [];
       state.history = trimHistory([...state.history, entry], cfg.historyWindow);
@@ -2069,7 +2089,7 @@ export default function register(api: OpenClawPluginApi): void {
     }
 
     if (decision.kind === "stable") {
-      pendingSoftSuspectSteeringBySession.delete(sessionKey);
+      clearSoftSuspectSteerState(sessionKey);
       const merged = [...state.history, ...state.pendingEntries, entry];
       for (const item of [...state.pendingEntries, entry]) {
         updateTopicCentroid(state, item.embedding);
@@ -2089,8 +2109,11 @@ export default function register(api: OpenClawPluginApi): void {
         pruneRecentMap(
           pendingSoftSuspectSteeringBySession,
           Math.max(cfg.softSuspect.ttlMs * 2, 60_000),
-          MAX_RECENT_FAST_EVENTS,
+          MAX_RECENT_MESSAGE_EVENTS,
         );
+        if (cfg.debug) {
+          api.logger.debug(`topic-shift-reset: suspect-queued session=${sessionKey}`);
+        }
       }
       state.pendingSoftSignals += 1;
       state.pendingEntries = trimHistory([...state.pendingEntries, entry], cfg.softConsecutiveSignals);
@@ -2117,7 +2140,7 @@ export default function register(api: OpenClawPluginApi): void {
     });
 
     if (rotated) {
-      pendingSoftSuspectSteeringBySession.delete(sessionKey);
+      clearSoftSuspectSteerState(sessionKey);
       if (!cfg.dryRun) {
         recentRotationBySession.set(`${sessionKey}:${contentHash}`, Date.now());
       }
@@ -2129,7 +2152,7 @@ export default function register(api: OpenClawPluginApi): void {
     const prunedRotations = pruneRecentMap(
       recentRotationBySession,
       ROTATION_DEDUPE_MS * 3,
-      MAX_RECENT_FAST_EVENTS,
+      MAX_RECENT_MESSAGE_EVENTS,
     );
     if (prunedRotations) {
       schedulePersistentFlush(false);
@@ -2137,7 +2160,7 @@ export default function register(api: OpenClawPluginApi): void {
   };
 
   const classifyAndMaybeRotate = async (params: {
-    source: "fast" | "fallback";
+    source: ClassificationSource;
     sessionKey: string;
     text: string;
     messageProvider?: string;
@@ -2170,19 +2193,19 @@ export default function register(api: OpenClawPluginApi): void {
       return;
     }
 
-    const fastEventKey = [
+    const userEventKey = [
       channelId,
       ctx.accountId ?? "",
       peer.kind,
       peer.id,
       hashString(normalizeTextForHash(text)),
     ].join("|");
-    const seenAt = recentFastEvents.get(fastEventKey);
-    if (typeof seenAt === "number" && Date.now() - seenAt < FAST_EVENT_TTL_MS) {
+    const seenAt = recentUserEvents.get(userEventKey);
+    if (typeof seenAt === "number" && Date.now() - seenAt < MESSAGE_EVENT_TTL_MS) {
       return;
     }
-    recentFastEvents.set(fastEventKey, Date.now());
-    pruneRecentMap(recentFastEvents, FAST_EVENT_TTL_MS, MAX_RECENT_FAST_EVENTS);
+    recentUserEvents.set(userEventKey, Date.now());
+    pruneRecentMap(recentUserEvents, MESSAGE_EVENT_TTL_MS, MAX_RECENT_MESSAGE_EVENTS);
 
     let resolvedSessionKey = "";
     let resolvedAgentId: string | undefined;
@@ -2198,14 +2221,14 @@ export default function register(api: OpenClawPluginApi): void {
     } catch (error) {
       if (cfg.debug) {
         api.logger.debug(
-          `topic-shift-reset: fast-route-skip channel=${channelId} peer=${maybeJson(peer)} err=${String(error)}`,
+          `topic-shift-reset: user-route-skip channel=${channelId} peer=${maybeJson(peer)} err=${String(error)}`,
         );
       }
       return;
     }
 
     await classifyAndMaybeRotate({
-      source: "fast",
+      source: "user",
       sessionKey: resolvedSessionKey,
       text,
       messageProvider: channelId,
@@ -2213,21 +2236,63 @@ export default function register(api: OpenClawPluginApi): void {
     });
   });
 
-  api.on("before_model_resolve", async (event, ctx) => {
+  api.on("message_sent", async (event, ctx) => {
     if (!cfg.enabled) {
       return;
     }
-    const sessionKey = ctx.sessionKey?.trim();
-    if (!sessionKey) {
+    if (!event.success) {
+      return;
+    }
+    const channelId = ctx.channelId?.trim();
+    if (!channelId) {
+      return;
+    }
+    const text = event.content?.trim() ?? "";
+    if (!text) {
+      return;
+    }
+
+    const peer = inferFastPeer({ from: event.to }, { conversationId: ctx.conversationId });
+    const agentEventKey = [
+      channelId,
+      ctx.accountId ?? "",
+      peer.kind,
+      peer.id,
+      hashString(normalizeTextForHash(text)),
+    ].join("|");
+    const seenAt = recentAgentEvents.get(agentEventKey);
+    if (typeof seenAt === "number" && Date.now() - seenAt < MESSAGE_EVENT_TTL_MS) {
+      return;
+    }
+    recentAgentEvents.set(agentEventKey, Date.now());
+    pruneRecentMap(recentAgentEvents, MESSAGE_EVENT_TTL_MS, MAX_RECENT_MESSAGE_EVENTS);
+
+    let resolvedSessionKey = "";
+    let resolvedAgentId: string | undefined;
+    try {
+      const route = api.runtime.channel.routing.resolveAgentRoute({
+        cfg: api.config,
+        channel: channelId,
+        accountId: ctx.accountId,
+        peer,
+      });
+      resolvedSessionKey = route.sessionKey;
+      resolvedAgentId = route.agentId;
+    } catch (error) {
+      if (cfg.debug) {
+        api.logger.debug(
+          `topic-shift-reset: agent-route-skip channel=${channelId} peer=${maybeJson(peer)} err=${String(error)}`,
+        );
+      }
       return;
     }
 
     await classifyAndMaybeRotate({
-      source: "fallback",
-      sessionKey,
-      text: event.prompt,
-      messageProvider: ctx.messageProvider,
-      agentId: ctx.agentId,
+      source: "agent",
+      sessionKey: resolvedSessionKey,
+      text,
+      messageProvider: channelId,
+      agentId: resolvedAgentId,
     });
   });
 
@@ -2239,15 +2304,36 @@ export default function register(api: OpenClawPluginApi): void {
     if (!sessionKey) {
       return;
     }
+    const now = Date.now();
+    const awaitingAt = awaitingSoftSuspectReplyBySession.get(sessionKey);
+    if (typeof awaitingAt === "number") {
+      if (now - awaitingAt > cfg.softSuspect.ttlMs) {
+        awaitingSoftSuspectReplyBySession.delete(sessionKey);
+      }
+      return;
+    }
+
     const seenAt = pendingSoftSuspectSteeringBySession.get(sessionKey);
     if (typeof seenAt !== "number") {
       return;
     }
-    if (Date.now() - seenAt > cfg.softSuspect.ttlMs) {
+    if (now - seenAt > cfg.softSuspect.ttlMs) {
       pendingSoftSuspectSteeringBySession.delete(sessionKey);
       return;
     }
+
+    if (cfg.softSuspect.mode === "strict") {
+      awaitingSoftSuspectReplyBySession.set(sessionKey, now);
+      pruneRecentMap(
+        awaitingSoftSuspectReplyBySession,
+        Math.max(cfg.softSuspect.ttlMs * 2, 60_000),
+        MAX_RECENT_MESSAGE_EVENTS,
+      );
+    }
     pendingSoftSuspectSteeringBySession.delete(sessionKey);
+    if (cfg.debug) {
+      api.logger.debug(`topic-shift-reset: ask-injected session=${sessionKey}`);
+    }
     return { prependContext: cfg.softSuspect.prompt };
   });