discoclaw 1.2.2 → 1.2.3

package/.env.example

@@ -234,6 +234,15 @@ DISCORD_GUILD_ID=
 # "anthropic-cache-telemetry" in journal output). Set LOG_LEVEL=debug for
 # full prompt section breakdowns.
 
+# ----------------------------------------------------------
+# Continuation capsule staleness
+# ----------------------------------------------------------
+# Maximum age (ms) of a continuation capsule before it is skipped at injection time.
+# Prevents stale context from prior conversations bleeding into unrelated sessions.
+# Capsules with an idle/awaiting currentFocus are always skipped regardless of age.
+# Default: 7200000 (2 hours). Set to 0 to disable TTL expiry (idle detection still applies).
+#DISCOCLAW_CAPSULE_TTL_MS=7200000
+
 # ----------------------------------------------------------
 # For all ~90 options (subsystems, actions, memory, identity,
 # observability, advanced/debug), see .env.example.full

package/.env.example.full

@@ -369,6 +369,11 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 #DISCOCLAW_MEMORY_CONSOLIDATION_MODEL=fast
 # Character budget for recent conversation history in prompts (0 = disabled).
 #DISCOCLAW_MESSAGE_HISTORY_BUDGET=3000
+# Maximum age (ms) of a continuation capsule before it is skipped at injection time.
+# Prevents stale context from prior conversations bleeding into unrelated sessions.
+# Capsules with an idle/awaiting/none currentFocus are always skipped regardless of age.
+# Default: 7200000 (2 hours). Set to 0 to disable TTL expiry (idle detection still applies).
+#DISCOCLAW_CAPSULE_TTL_MS=7200000
 
 # ----------------------------------------------------------
 # Cold storage — vector-indexed conversation history (off by default)

package/dist/config.js

@@ -704,6 +704,7 @@ export function parseConfig(env) {
             summaryTargetRatio: parseZeroToOneExclusive(env, 'DISCOCLAW_SUMMARY_TARGET_RATIO', 0.65),
             summaryDataDirOverride: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_DATA_DIR'),
             summaryArchiveDirOverride: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_ARCHIVE_DIR'),
+            capsuleTtlMs: parseNonNegativeInt(env, 'DISCOCLAW_CAPSULE_TTL_MS', 7_200_000),
             durableMemoryEnabled: parseBoolean(env, 'DISCOCLAW_DURABLE_MEMORY_ENABLED', true),
             durableDataDirOverride: parseTrimmedString(env, 'DISCOCLAW_DURABLE_DATA_DIR'),
             durableInjectMaxChars: parsePositiveInt(env, 'DISCOCLAW_DURABLE_INJECT_MAX_CHARS', 2000),

package/dist/discord/capsule-invalidation.js

@@ -0,0 +1,52 @@
+/**
+ * Default TTL for continuation capsules: 2 hours.
+ * If the parent summary's updatedAt is older than this, the capsule is
+ * considered stale and should not be injected.
+ */
+export const DEFAULT_CAPSULE_TTL_MS = 2 * 60 * 60 * 1000;
+/**
+ * Patterns in `currentFocus` that indicate the capsule carries no useful
+ * state — the assistant was idle, awaiting input, or had no active task.
+ */
+const IDLE_FOCUS_PATTERNS = [
+    /^idle$/i,
+    /^none$/i,
+    /^awaiting\b/i,
+    /^waiting\b/i,
+    /^no active task/i,
+    /^n\/a$/i,
+    /^\(none\)$/i,
+    /^\(idle\)$/i,
+    /^\(awaiting\b/i,
+];
+/**
+ * Returns true when the capsule's `currentFocus` matches an idle/no-state
+ * pattern, meaning the capsule should not be injected.
+ */
+export function isCapsuleIdle(capsule) {
+    const focus = capsule.currentFocus.trim();
+    return IDLE_FOCUS_PATTERNS.some(pattern => pattern.test(focus));
+}
+/**
+ * Returns true when the parent summary's `updatedAt` exceeds the staleness
+ * threshold relative to `now`.
+ */
+export function isCapsuleExpired(updatedAt, now = Date.now(), ttlMs = DEFAULT_CAPSULE_TTL_MS) {
+    if (ttlMs <= 0)
+        return false;
+    return now - updatedAt > ttlMs;
+}
+/**
+ * Combined check: returns whether a capsule should be injected into
+ * the conversation prompt. Both idle detection and TTL expiry are
+ * evaluated; idle is checked first (cheaper).
+ */
+export function validateCapsuleForInjection(capsule, updatedAt, opts) {
+    if (isCapsuleIdle(capsule)) {
+        return { valid: false, reason: 'idle' };
+    }
+    if (isCapsuleExpired(updatedAt, opts?.now, opts?.ttlMs)) {
+        return { valid: false, reason: 'expired' };
+    }
+    return { valid: true };
+}

package/dist/discord/capsule-invalidation.test.js

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_CAPSULE_TTL_MS, isCapsuleIdle, isCapsuleExpired, validateCapsuleForInjection, } from './capsule-invalidation.js';
+function makeCapsule(currentFocus) {
+    return { currentFocus, nextStep: 'do something' };
+}
+describe('isCapsuleIdle', () => {
+    it.each([
+        'idle',
+        'Idle',
+        'IDLE',
+        'none',
+        'None',
+        'NONE',
+        'awaiting input',
+        'Awaiting user response',
+        'waiting for user',
+        'Waiting on feedback',
+        'no active task',
+        'No active task right now',
+        'n/a',
+        'N/A',
+        '(none)',
+        '(None)',
+        '(idle)',
+        '(Idle)',
+        '(awaiting input)',
+        '(Awaiting response)',
+    ])('returns true for idle focus: %s', (focus) => {
+        expect(isCapsuleIdle(makeCapsule(focus))).toBe(true);
+    });
+    it.each([
+        'Implement feature X',
+        'Debugging the parser',
+        'idling is not the same',
+        'nonetheless important',
+    ])('returns false for active focus: %s', (focus) => {
+        expect(isCapsuleIdle(makeCapsule(focus))).toBe(false);
+    });
+    it('trims whitespace before matching', () => {
+        expect(isCapsuleIdle(makeCapsule('  idle  '))).toBe(true);
+        expect(isCapsuleIdle(makeCapsule('  none  '))).toBe(true);
+    });
+});
+describe('isCapsuleExpired', () => {
+    it('returns false when within TTL', () => {
+        const now = Date.now();
+        const updatedAt = now - (DEFAULT_CAPSULE_TTL_MS - 1000);
+        expect(isCapsuleExpired(updatedAt, now)).toBe(false);
+    });
+    it('returns true when past default TTL', () => {
+        const now = Date.now();
+        const updatedAt = now - DEFAULT_CAPSULE_TTL_MS - 1;
+        expect(isCapsuleExpired(updatedAt, now)).toBe(true);
+    });
+    it('returns false at exactly the TTL boundary', () => {
+        const now = Date.now();
+        const updatedAt = now - DEFAULT_CAPSULE_TTL_MS;
+        expect(isCapsuleExpired(updatedAt, now)).toBe(false);
+    });
+    it('respects a custom ttlMs', () => {
+        const now = 100_000;
+        expect(isCapsuleExpired(90_000, now, 5_000)).toBe(true); // 10s > 5s TTL
+        expect(isCapsuleExpired(96_000, now, 5_000)).toBe(false); // 4s < 5s TTL
+    });
+    it('returns false when ttlMs is 0 (TTL disabled)', () => {
+        const now = 100_000;
+        expect(isCapsuleExpired(1, now, 0)).toBe(false);
+    });
+    it('returns false when ttlMs is negative (TTL disabled)', () => {
+        const now = 100_000;
+        expect(isCapsuleExpired(1, now, -1)).toBe(false);
+    });
+    it('DEFAULT_CAPSULE_TTL_MS is 2 hours', () => {
+        expect(DEFAULT_CAPSULE_TTL_MS).toBe(2 * 60 * 60 * 1000);
+    });
+});
+describe('validateCapsuleForInjection', () => {
+    const now = 1_000_000;
+    const freshUpdatedAt = now - 60_000; // 1 minute ago
+    it('returns valid for active, fresh capsule', () => {
+        const capsule = makeCapsule('Implementing feature X');
+        const result = validateCapsuleForInjection(capsule, freshUpdatedAt, { now });
+        expect(result).toEqual({ valid: true });
+    });
+    it('returns idle reason for idle capsule', () => {
+        const capsule = makeCapsule('idle');
+        const result = validateCapsuleForInjection(capsule, freshUpdatedAt, { now });
+        expect(result).toEqual({ valid: false, reason: 'idle' });
+    });
+    it('returns expired reason for stale capsule', () => {
+        const capsule = makeCapsule('Implementing feature X');
+        const staleUpdatedAt = now - DEFAULT_CAPSULE_TTL_MS - 1;
+        const result = validateCapsuleForInjection(capsule, staleUpdatedAt, { now });
+        expect(result).toEqual({ valid: false, reason: 'expired' });
+    });
+    it('idle takes precedence over expired', () => {
+        const capsule = makeCapsule('none');
+        const staleUpdatedAt = now - DEFAULT_CAPSULE_TTL_MS - 1;
+        const result = validateCapsuleForInjection(capsule, staleUpdatedAt, { now });
+        expect(result).toEqual({ valid: false, reason: 'idle' });
+    });
+    it('respects custom ttlMs via opts', () => {
+        const capsule = makeCapsule('Working on task');
+        const updatedAt = now - 10_000; // 10s ago
+        const result = validateCapsuleForInjection(capsule, updatedAt, { now, ttlMs: 5_000 });
+        expect(result).toEqual({ valid: false, reason: 'expired' });
+    });
+});

package/dist/discord/message-coordinator.js

@@ -19,6 +19,7 @@ import { resolveGroundedToolCapabilities } from '../runtime/tool-capabilities.js
 import { fetchMessageHistory } from './message-history.js';
 import { loadSummary, saveSummary, generateSummary, archiveSummary, recompressSummary, estimateSummaryTokens, buildConversationMemorySection, } from './summarizer.js';
 import { parseCapsuleBlock } from './capsule.js';
+import { validateCapsuleForInjection } from './capsule-invalidation.js';
 import { parseMemoryCommand, handleMemoryCommand } from './memory-commands.js';
 import { parseSecretCommand, handleSecretCommand } from './secret-commands.js';
 import { parsePlanCommand, handlePlanCommand, preparePlanRun, handlePlanSkip, closePlanIfComplete, NO_PHASES_SENTINEL, findPlanFile, looksLikePlanId, PLAN_DISABLED_NUDGE } from './plan-commands.js';
@@ -2717,6 +2718,13 @@ export function createMessageCreateHandler(params, queue, statusRef) {
                                     existingSummaryUpdatedAt = existing.updatedAt;
                                     existingSummaryRegeneratedAt = existing.regeneratedAt;
                                     existingContinuationCapsule = existing.continuationCapsule;
+                                    if (existingContinuationCapsule) {
+                                        const capsuleCheck = validateCapsuleForInjection(existingContinuationCapsule, existing.updatedAt, { ttlMs: params.capsuleTtlMs });
+                                        if (!capsuleCheck.valid) {
+                                            params.log?.info({ reason: capsuleCheck.reason, sessionKey }, 'discord:capsule skipped at injection');
+                                            existingContinuationCapsule = undefined;
+                                        }
+                                    }
                                     summarySection = buildConversationMemorySection(existingSummaryText, {
                                         turnsSinceUpdate: existing.turnsSinceUpdate,
                                         regeneratedAt: existing.regeneratedAt,

package/dist/index.js

@@ -425,6 +425,7 @@ const summaryMaxChars = cfg.summaryMaxChars;
 const summaryEveryNTurns = cfg.summaryEveryNTurns;
 const summaryMaxTokens = cfg.summaryMaxTokens;
 const summaryTargetRatio = cfg.summaryTargetRatio;
+const capsuleTtlMs = cfg.capsuleTtlMs;
 const summaryDataDir = cfg.summaryDataDirOverride
     || (dataDir ? path.join(dataDir, 'memory', 'rolling') : path.join(__dirname, '..', 'data', 'memory', 'rolling'));
 const summaryArchiveDir = cfg.summaryArchiveDirOverride
@@ -1275,6 +1276,7 @@ const botParams = {
     summaryTargetRatio,
     summaryDataDir,
     summaryArchiveDir,
+    capsuleTtlMs,
     durableMemoryEnabled,
     durableDataDir,
     durableInjectMaxChars,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Personal AI orchestrator that turns Discord into a persistent workspace",
   "license": "MIT",
   "keywords": [