@martian-engineering/lossless-claw 0.11.3 → 0.12.0

package/docs/architecture.md

@@ -212,6 +212,17 @@ LCM handles crash recovery through **bootstrap reconciliation**:
 
 This handles the case where OpenClaw wrote messages to the session file but crashed before LCM could persist them.
 
+For forked child sessions, LCM treats a host-copied parent JSONL branch as a
+first-time bootstrap source and imports only the newest messages that fit within
+`bootstrapMaxTokens`. That keeps child LCM state bounded even if the host fork
+payload still contains a long raw parent branch. The remaining fork-continuity
+contract belongs to the host: when lossless-claw advertises the
+`subagent-spawn` requirement for `thread-bootstrap-projection`, OpenClaw should
+bootstrap the child model thread from the context-engine projection rather than
+from the raw copied transcript. If the host cannot provide that capability,
+lossless-claw can preserve bounded durable state, but it cannot stop the host
+from replaying raw JSONL into the model before assembly.
+
 ## Operation serialization
 
 All mutating operations (ingest, compact) are serialized per-session using a promise queue. This prevents races between concurrent afterTurn/compact calls for the same conversation without blocking operations on different conversations.

package/docs/configuration.md

@@ -58,6 +58,9 @@ Most installations only need to override a handful of keys. If you want a comple
   "expansionModel": "",
   "delegationTimeoutMs": 120000,
   "summaryTimeoutMs": 60000,
+  "summaryCallWindowMs": 600000,
+  "summaryMaxCallsPerWindow": 24,
+  "summarySpendBackoffMs": 1800000,
   "timezone": "America/Los_Angeles",
   "pruneHeartbeatOk": false,
   "transcriptGcEnabled": false,
@@ -87,7 +90,13 @@ Most installations only need to override a handful of keys. If you want a comple
   "dynamicLeafChunkTokens": {
     "enabled": true,
     "max": 40000
-  }
+  },
+  "stripInjectedContextTags": [
+    "active_memory_plugin",
+    "relevant-memories",
+    "relevant_memories",
+    "hindsight_memories"
+  ]
 }
 ```
 
@@ -144,11 +153,11 @@ openclaw plugins install --link /path/to/lossless-claw
 | `autoRotateSessionFiles.createBackups` | `boolean` | `false` | `LCM_AUTO_ROTATE_SESSION_FILES_CREATE_BACKUPS` | Creates or replaces the rolling `rotate-latest` SQLite backup before automatic session-file rotation. Manual `/lcm rotate` backups are always created. |
 | `autoRotateSessionFiles.sizeBytes` | `integer` | `2097152` | `LCM_AUTO_ROTATE_SESSION_FILES_SIZE_BYTES` | Byte threshold that triggers automatic session-file rotation. |
 | `autoRotateSessionFiles.startup` | `"rotate" \| "warn" \| "off"` | `"rotate"` | `LCM_AUTO_ROTATE_SESSION_FILES_STARTUP` | Startup behavior for oversized indexed OpenClaw session transcripts that also have active LCM bootstrap state. |
-| `autoRotateSessionFiles.runtime` | `"rotate" \| "warn" \| "off"` | `"rotate"` | `LCM_AUTO_ROTATE_SESSION_FILES_RUNTIME` | Runtime behavior after `afterTurn()` and `maintain()` check the current transcript size. |
+| `autoRotateSessionFiles.runtime` | `"rotate" \| "warn" \| "off"` | `"rotate"` | `LCM_AUTO_ROTATE_SESSION_FILES_RUNTIME` | Runtime behavior after post-turn checks. Runtime `rotate` logs deferral for active session JSONL rewrites and leaves direct rotation to startup or manual `/lcm rotate`. |
 
 > **Multi-profile note:** `OPENCLAW_STATE_DIR` (set by the host OpenClaw gateway) controls where state is stored. When two gateways run on the same host (e.g. separate bot personas), each gateway sets its own `OPENCLAW_STATE_DIR` and lossless-claw automatically uses that directory for the database, large-file payloads, auth-profile lookups, and legacy secrets — no per-profile plugin config is needed.
 
-Automatic session-file rotation rewrites only the live session transcript, keeps the active LCM conversation and durable history intact, and refreshes the bootstrap checkpoint. Startup rotation first scans OpenClaw's current indexed session stores for configured agents, then intersects those candidates with active LCM conversations and matching bootstrap file mappings. Automatic rotation does not create a SQLite backup by default; set `autoRotateSessionFiles.createBackups` to `true` to make runtime rotation replace the rolling `rotate-latest` backup and to make startup rotation create one pre-rotation LCM database backup for the batch before any transcript is rewritten. Manual `/lcm rotate` always keeps its backup-backed behavior regardless of this flag. Rotation never runs for ignored sessions, stateless sessions, or sessions without active LCM state. The preserved JSONL tail follows the existing rotate behavior, which is controlled by `freshTailCount`.
+Automatic session-file rotation rewrites only the live session transcript, keeps the active LCM conversation and durable history intact, and refreshes the bootstrap checkpoint. Before manual or startup rewrites, rotation forces leaf-only compaction for raw context outside the preserved tail so trimmed transcript messages are covered by LCM summaries without running unrelated summary-condensation passes. Startup rotation first scans OpenClaw's current indexed session stores for configured agents, then intersects those candidates with active LCM conversations and matching bootstrap file mappings. Runtime rotation checks from `afterTurn()` and `maintain()` intentionally do not directly rewrite active session JSONL because embedded prompt-lock fences can still be open while tool-call loops and host background maintenance overlap; runtime `rotate` logs a deferral until startup, manual `/lcm rotate`, or a future host-owned full-transcript rewrite primitive is available. Automatic rotation does not create a SQLite backup by default; set `autoRotateSessionFiles.createBackups` to `true` to make startup rotation create one pre-rotation LCM database backup for the batch before any transcript is rewritten. Manual `/lcm rotate` always keeps its backup-backed behavior regardless of this flag. Rotation never runs for ignored sessions, stateless sessions, or sessions without active LCM state. The preserved JSONL tail follows the existing rotate behavior, which is controlled by `freshTailCount`. Transcript GC uses the host-provided `rewriteTranscriptEntries` primitive and defers until host-approved background maintenance when `transcriptGcEnabled` is enabled.
 
 Every automatic decision emits grep-able log lines prefixed with `[lcm] auto-rotate:`. Startup emits one compact summary line with `phase=startup`, `action=summary`, `scanned`, `eligible`, `rotated`, `warned`, `skipped`, `durationMs`, `bytesRemoved`, and backup fields when a batch backup was created; quiet skips such as missing files, missing bootstrap mappings, and below-threshold files are counted there instead of producing one line per candidate. Rotation detail lines include `phase`, `action`, `sessionId`, `sessionKey`, `sessionFile`, `sizeBytes`, `thresholdBytes`, `durationMs`, `backupPath`, `bytesRemoved`, `preservedTailMessageCount`, and `checkpointSize`; real warning lines include the same available context plus `reason` or `error`.
 
@@ -180,6 +189,13 @@ Every automatic decision emits grep-able log lines prefixed with `[lcm] auto-rot
 | `maxAssemblyTokenBudget` | `integer` | unset | `LCM_MAX_ASSEMBLY_TOKEN_BUDGET` | Optional hard cap for assembly and threshold evaluation, useful with smaller-context models. |
 | `maxExpandTokens` | `integer` | `4000` | `LCM_MAX_EXPAND_TOKENS` | Default token cap for `lcm_expand_query` responses. |
 
+Forked child transcripts are also bounded by `bootstrapMaxTokens` when a host
+copies a raw parent JSONL branch into the child file. This protects the LCM
+database from importing unbounded parent history, but the host must still honor
+the `thread-bootstrap-projection` context-engine capability for subagent or
+thread forks so the model starts from the LCM-assembled compact view instead of
+the raw copied transcript.
+
 ### Model selection, execution, and prompts
 
 | Key | Type | Default | Env override | Purpose |
@@ -192,6 +208,9 @@ Every automatic decision emits grep-able log lines prefixed with `[lcm] auto-rot
 | `expansionProvider` | `string` | `""` | `LCM_EXPANSION_PROVIDER` | `lcm_expand_query` sub-agent provider hint for bare model names. |
 | `delegationTimeoutMs` | `integer` | `120000` | `LCM_DELEGATION_TIMEOUT_MS` | Maximum time to wait for delegated expansion work. `lcm_expand_query` advertises a dynamic tool `timeoutMs` default with 30 seconds of extra RPC headroom so OpenClaw's tool watchdog does not fire before this wait completes. |
 | `summaryTimeoutMs` | `integer` | `60000` | `LCM_SUMMARY_TIMEOUT_MS` | Maximum time to wait for one model-backed summarizer call. |
+| `summaryCallWindowMs` | `integer` | `600000` | `LCM_SUMMARY_CALL_WINDOW_MS` | Rolling window for the per-session summarization spend guard. |
+| `summaryMaxCallsPerWindow` | `integer` | `24` | `LCM_SUMMARY_MAX_CALLS_PER_WINDOW` | Maximum model-backed summarization calls per session/window before Lossless opens a non-auth spend backoff. |
+| `summarySpendBackoffMs` | `integer` | `1800000` | `LCM_SUMMARY_SPEND_BACKOFF_MS` | Cooldown after the summarization spend guard opens. |
 | `customInstructions` | `string` | `""` | `LCM_CUSTOM_INSTRUCTIONS` | Extra natural-language instructions injected into every summarization prompt. |
 
 Summary calls are executed through OpenClaw's `api.runtime.llm.complete` capability. If you configure an explicit Lossless summary model (`summaryModel`, `largeFileSummaryModel`, or `fallbackProviders`), OpenClaw must allow that runtime LLM override under `plugins.entries.lossless-claw.llm.allowModelOverride` and `plugins.entries.lossless-claw.llm.allowedModels`. `openclaw doctor --fix` can add the minimal policy entries for configured Lossless summary models. Delegated expansion calls use OpenClaw's runtime sub-agent layer; explicit `expansionModel` values require `plugins.entries.lossless-claw.subagent.allowModelOverride` and a matching `subagent.allowedModels` entry, or `"*"` if you intentionally trust any expansion target. `openclaw doctor --fix` can add the minimal subagent policy, and `lcm_expand_query` retries once without the override if the host rejects it.
@@ -203,6 +222,7 @@ Summary calls are executed through OpenClaw's `api.runtime.llm.complete` capabil
 | `fallbackProviders` | `Array<{ provider: string; model: string }>` | `[]` | `LCM_FALLBACK_PROVIDERS` | Explicit provider/model fallback chain for compaction summarization. Format for env vars is `provider/model,provider/model`. |
 | `circuitBreakerThreshold` | `integer` | `5` | `LCM_CIRCUIT_BREAKER_THRESHOLD` | Consecutive auth failures before the summarization circuit breaker trips. |
 | `circuitBreakerCooldownMs` | `integer` | `1800000` | `LCM_CIRCUIT_BREAKER_COOLDOWN_MS` | Cooldown before the summarization circuit breaker resets automatically. |
+| `stripInjectedContextTags` | `string[]` | `["active_memory_plugin", "relevant-memories", "relevant_memories", "hindsight_memories"]` | `LCM_STRIP_INJECTED_CONTEXT_TAGS` | XML tag names whose blocks are stripped from message content before compaction summarization. Memory/context plugins inject these via `prependContext`; stripping prevents ephemeral retrieval context from polluting compacted summaries. Env var format is comma-separated tag names. Set to `[]` (or empty env string) to disable. |
 
 ### Nested objects
 
@@ -232,7 +252,8 @@ Automatic compaction is threshold-only:
 - `afterTurn()` evaluates `contextThreshold` against the active token budget
 - below threshold, no automatic compaction runs and no leaf debt is recorded
 - at or above threshold, inline mode runs a threshold full sweep immediately
-- deferred mode records one coalesced `"threshold"` maintenance row and drains it in the background, `maintain()`, or pre-assembly
+- deferred mode records one coalesced `"threshold"` maintenance row and normally drains it in the background or host-approved `maintain()`
+- pre-assembly drain is reserved as an emergency safeguard when the live prompt is already over the active token budget
 
 Lossless still records prompt-cache telemetry for status and diagnostics, but cache hotness no longer delays threshold debt. Legacy `cacheAwareCompaction.*` and `dynamicLeafChunkTokens.*` settings remain accepted so existing OpenClaw config continues to load, but they do not change automatic compaction behavior.
 
@@ -287,6 +308,8 @@ LCM_EXPANSION_MODEL=openai/gpt-5.4-mini
 - `*` matches any characters except `:`
 - `**` matches anything, including `:`
 
+Cron scheduler keys (`agent:<agent>:cron:<job>...`) are isolated automatically when a new runtime `sessionId` reuses the same `sessionKey`. Configure `ignoreSessionPatterns` for cron only when the run should bypass LCM entirely; leave cron sessions included when they need in-run compaction.
+
 Example:
 
 ```json
@@ -318,7 +341,8 @@ Lossless-claw now defaults `proactiveThresholdCompactionMode` to `deferred`.
 - deferred mode records a single coalesced maintenance debt row per conversation
 - new deferred compaction debt is only created for `contextThreshold` pressure and uses reason `"threshold"`
 - `maintain()` consumes threshold debt when the host explicitly opts in to deferred execution
-- `assemble()` consumes pending threshold debt before building the next prompt
+- `assemble()` leaves pending threshold debt for after-turn background drain or host-approved `maintain()` while the live prompt is still within budget
+- `assemble()` only consumes pending threshold debt synchronously as an emergency safeguard when the live prompt estimate is already over the active token budget
 - old non-threshold debt from earlier builds is revalidated; if the conversation is no longer over threshold, it is cleared as a no-op
 - `/lcm status` / `/lossless status` shows the current maintenance state, including pending/running/last-failure details
 - status output also surfaces the latest API/cache telemetry as diagnostics, not as a deferral gate

package/openclaw.plugin.json

@@ -1,5 +1,6 @@
 {
   "id": "lossless-claw",
+  "name": "Lossless Context Management",
   "kind": "context-engine",
   "activation": {
     "onStartup": true
@@ -168,6 +169,18 @@
       "label": "Summary Timeout (ms)",
       "help": "Maximum time to wait for a single model-backed LCM summarizer call before timing out"
     },
+    "summaryCallWindowMs": {
+      "label": "Summary Call Window (ms)",
+      "help": "Rolling window used by the summarization spend guard"
+    },
+    "summaryMaxCallsPerWindow": {
+      "label": "Summary Max Calls Per Window",
+      "help": "Maximum model-backed summarization calls per session/window before Lossless opens a non-auth spend backoff"
+    },
+    "summarySpendBackoffMs": {
+      "label": "Summary Spend Backoff (ms)",
+      "help": "Cooldown after the summarization spend guard opens"
+    },
     "maxAssemblyTokenBudget": {
       "label": "Max Assembly Token Budget",
       "help": "Hard ceiling for assembly token budget — caps runtime-provided and fallback budgets. Set for smaller context-window models (e.g., 30000 for 32k models)"
@@ -263,6 +276,10 @@
     "fallbackProviders": {
       "label": "Fallback Providers",
       "help": "Explicit runtime LLM fallback provider/model pairs for compaction summarization; entries require plugins.entries.lossless-claw.llm policy"
+    },
+    "stripInjectedContextTags": {
+      "label": "Strip Injected Context Tags",
+      "help": "XML tag names whose blocks are stripped from messages before summarization. Covers memory/context plugin prepended blocks (active-memory, memory-lancedb, hindsight-openclaw). Set to [] to disable."
     }
   },
   "configSchema": {
@@ -406,6 +423,18 @@
         "type": "integer",
         "minimum": 1
       },
+      "summaryCallWindowMs": {
+        "type": "integer",
+        "minimum": 1
+      },
+      "summaryMaxCallsPerWindow": {
+        "type": "integer",
+        "minimum": 1
+      },
+      "summarySpendBackoffMs": {
+        "type": "integer",
+        "minimum": 1
+      },
       "maxAssemblyTokenBudget": {
         "type": "integer",
         "minimum": 1000
@@ -540,6 +569,13 @@
           "required": ["provider", "model"],
           "additionalProperties": false
         }
+      },
+      "stripInjectedContextTags": {
+        "description": "XML tag names whose blocks are stripped from messages before summarization. Memory/context plugins prepend tagged blocks via prependContext that should not leak into compacted summaries.",
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with threshold compaction",
   "type": "module",
   "main": "dist/index.js",
@@ -18,8 +18,10 @@
   "scripts": {
     "build": "esbuild index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.js --external:openclaw --external:\"@earendil-works/*\" --minify-whitespace",
     "changeset": "changeset",
-    "release:verify": "npm run build && npm test && npm pack --dry-run",
+    "plugin-inspector:ci": "npm exec --yes --package @openclaw/plugin-inspector@0.3.11 -- plugin-inspector ci --plugin-root . --out plugin-inspector-reports",
+    "release:verify": "npm run typecheck && npm run build && npm test && npm pack --dry-run",
     "test": "vitest run --dir test",
+    "typecheck": "tsc --noEmit --pretty false",
     "version-packages": "changeset version"
   },
   "files": [

package/skills/lossless-claw/references/config.md

@@ -296,7 +296,7 @@ Why it matters:
 - `deferred` also stores provider/model/cache telemetry so Anthropic-family sessions can avoid rewriting a still-hot prompt cache
 - `inline` preserves the legacy foreground compaction path for hosts that do not yet support deferred execution
 - `/lossless status` and `/lcm status` surface pending/running/last-failure maintenance state so operators can see when compaction is queued
-- background `maintain()` can still do non-prompt-mutating work, but prompt-mutating debt is consumed pre-assembly once cache is cold or the next turn is already approaching overflow
+- after-turn background drain and host-approved `maintain()` consume routine threshold debt; `assemble()` only drains pending threshold debt synchronously as an emergency safeguard when the live prompt estimate is already over budget
 
 ### `autoRotateSessionFiles`
 
@@ -314,6 +314,7 @@ Why it matters:
 
 - prevents very large OpenClaw session JSONL files from choking fallback/gateway startup while LCM owns the durable context
 - runtime rotation only creates or replaces the rolling `rotate-latest` DB backup when `createBackups` is `true`; manual `/lossless rotate` / `/lcm rotate` always keeps its backup-backed behavior
+- runtime JSONL rewrites run from `afterTurn()` after the host turn completes; `maintain()` skips rotation and leaves it to `afterTurn()` or startup because background maintenance can overlap an embedded model call
 - startup scans OpenClaw's current indexed session stores for configured agents, intersects those candidates with active LCM bootstrap state, and creates one pre-rotation DB backup for the startup batch only when `createBackups` is `true`
 - only runs for active, writable LCM conversations; ignored sessions, stateless sessions, sessions outside the indexed startup candidate set, and sessions without active LCM state are skipped
 - the preserved transcript tail follows the normal rotate behavior controlled by `freshTailCount`
@@ -468,6 +469,7 @@ Why it matters:
 
 - keeps low-value automation or noisy sessions out of the DB
 - useful for excluding certain agent lanes or ephemeral traffic entirely
+- cron scheduler keys are already isolated per runtime run, so ignore them only when they should bypass LCM compaction
 
 ### `statelessSessionPatterns`
 
@@ -622,6 +624,28 @@ Why it matters:
 - guards against runaway summaries that are much larger than their target budget
 - useful when summary models are verbose or unstable
 
+### `summaryMaxCallsPerWindow`, `summaryCallWindowMs`, and `summarySpendBackoffMs`
+
+Bounds model-backed compaction and large-file summarization calls per session.
+
+Defaults:
+
+- `summaryMaxCallsPerWindow`: `24`
+- `summaryCallWindowMs`: `600000`
+- `summarySpendBackoffMs`: `1800000`
+
+Env overrides:
+
+- `LCM_SUMMARY_MAX_CALLS_PER_WINDOW`
+- `LCM_SUMMARY_CALL_WINDOW_MS`
+- `LCM_SUMMARY_SPEND_BACKOFF_MS`
+
+Why they matter:
+
+- prevents non-auth provider failures, ineffective compaction, or repeated deferred debt from spending unbounded summarization calls
+- keeps provider-auth failures on the separate auth circuit breaker path
+- direct deterministic fallbacks remain available when model-backed large-file summaries are throttled
+
 ### `customInstructions`
 
 Natural-language instructions injected into summarization prompts.
@@ -631,6 +655,25 @@ Why it matters:
 - lets operators steer formatting or emphasis without patching code
 - should be used sparingly; low-quality instructions can degrade summary quality system-wide
 
+### `stripInjectedContextTags`
+
+| | |
+| --- | --- |
+| Type | `string[]` |
+| Default | `["active_memory_plugin", "relevant-memories", "relevant_memories", "hindsight_memories"]` |
+| Env | `LCM_STRIP_INJECTED_CONTEXT_TAGS` (comma-separated) |
+
+XML tag names whose blocks are stripped from message content before compaction summarization.
+
+Why it matters:
+
+- Memory and context plugins (active-memory, memory-lancedb, hindsight-openclaw) prepend XML-tagged blocks to user messages via the `prependContext` hook.  These blocks are ephemeral retrieval context — they helped the model on that specific turn but are not part of the actual conversation.
+- Without stripping, the summarizer treats injected memories as real conversation content, permanently corrupting compacted summaries with auto-retrieved context that the user never said.
+- The default list covers well-known OpenClaw memory plugin tags.  Add custom tag names if you use plugins that inject context via other tags.
+- Set to `[]` (or empty env string) to disable stripping.
+
+Design note: stripping happens at compaction time, not at message ingestion.  The raw message stored in the LCM database still contains the original injected blocks, so `lcm_expand` and `lcm_grep` can still surface the full context the model saw on any given turn.  Only the summarizer input is cleaned.
+
 ## Practical operator workflow
 
 1. Install and enable the plugin.

package/skills/lossless-claw/references/session-lifecycle.md

@@ -8,25 +8,28 @@ For stock `lossless-claw` on current main:
 
 - OpenClaw handles `/new` and `/reset` as session-reset operations.
 - `lossless-claw` handles `/lossless rotate` (`/lcm rotate`) as transcript maintenance on the current conversation.
-- `lossless-claw` does **not** currently register its own `before_reset` hook or a custom reset policy.
 - `lossless-claw` prefers **`sessionKey`** as the stable identity for an LCM conversation.
-- When the same `sessionKey` reappears with a new `sessionId`, `lossless-claw` updates the stored `sessionId` on the existing LCM conversation row instead of creating a brand-new LCM conversation.
+- `/reset` archives the active conversation and creates a fresh active row for the same stable `sessionKey`.
+- Cron scheduler keys (`agent:<agent>:cron:<job>...`) are isolated per runtime run when a new `sessionId` reuses the same `sessionKey`.
+- For ordinary non-cron session keys, continuity still follows the stable `sessionKey`.
 
 ## What that means in practice
 
-If a user asks whether `/new` or `/reset` gives them a fresh LCM conversation, the answer is usually **no** under the current implementation.
+If a user asks whether `/new` or `/reset` gives them a fresh LCM conversation, distinguish the commands.
 
-They get a fresh OpenClaw session runtime, but LCM continuity still follows the stable `sessionKey` when one is available.
+They get a fresh OpenClaw session runtime, but LCM continuity usually still follows the stable `sessionKey` when one is available.
 
 So today:
 
-- `/new` and `/reset` can reset the runtime session
-- but LCM history may continue in the same conversation row if the chat/thread keeps the same `sessionKey`
+- `/new` prunes active context but keeps the same LCM conversation row
+- `/reset` archives the active LCM conversation row and creates a fresh active row
+- ordinary chat/thread LCM history may continue in the same row across runtime `sessionId` changes when the stable `sessionKey` continues
+- cron scheduler keys create fresh LCM rows per runtime run so prior runs do not enter the new run's assembled context
 - `/lossless rotate` keeps that same conversation row, summaries, and context items in place while compacting only the live transcript backing
 
 ## Why
 
-Current lossless-claw conversation resolution does this:
+Current lossless-claw conversation resolution generally does this:
 
 1. look up by `sessionKey` first
 2. fall back to `sessionId` only when no `sessionKey` match exists
@@ -34,6 +37,8 @@ Current lossless-claw conversation resolution does this:
 
 That behavior preserves continuity across session resets for the same chat identity.
 
+Cron keys are the exception: when an active cron conversation exists for the same `sessionKey` but a different runtime `sessionId`, lossless-claw archives the prior active row and starts a fresh one for the new run. Prior messages remain persisted on the archived conversation.
+
 ## `/lossless rotate`
 
 `/lossless rotate` is distinct from `/new` and `/reset`.
@@ -49,22 +54,23 @@ This makes rotate the lightweight option when the problem is transcript bloat ra
 
 ## Important limitation
 
-There is still **no plugin-specific `/new` vs `/reset` split** in stock lossless-claw docs or runtime behavior.
+There is a plugin-specific `/new` vs `/reset` split in current lossless-claw behavior.
 
 If someone is asking for semantics like:
 
 - `/new` gives them a fresh LCM conversation row
-- `/reset` archives old LCM conversation and starts a new one for the same stable `sessionKey`
 
-that is a **design/spec topic**, not current stock behavior.
+that remains a **design/spec topic**, not current stock behavior.
 
 ## Safe operator guidance
 
 When answering users:
 
-- do not promise that `/new` or `/reset` clears LCM history
+- do not promise that `/new` clears LCM history
+- explain that `/reset` archives the active LCM row and starts a fresh one for the same stable `sessionKey`
 - explain that `/lossless rotate` compacts the current transcript without splitting the LCM conversation
-- explain that current stock behavior follows `sessionKey` continuity
+- explain that ordinary current stock behavior follows `sessionKey` continuity
+- explain that cron scheduler session keys are isolated per runtime run while preserving archived prior runs
 - if they need a truly separate LCM history, use a different session key context (for example a different chat/thread/binding) or explicit non-MVP migration/surgery tools
 
 ## Relation to `/status`