discoclaw 0.5.1 → 0.5.3

package/.context/memory.md

@@ -33,7 +33,10 @@ Bot:             We've been working through your Express → Fastify migration.
 
 Structured store of user facts. Each item has a kind (fact, preference, project,
 constraint, person, tool, workflow), deduplication by content hash, and a 200-item
-cap per user. Injected into every prompt.
+cap per user. Items track `hitCount` (incremented each time the item is selected
+for prompt injection) and `lastHitAt` (timestamp of most recent selection).
+Injected into every prompt using a blended score of recency and usage frequency
+rather than raw `updatedAt` alone.
 
 **What the user sees:**
 - The bot knows your preferences, projects, and key facts across all conversations.
@@ -53,7 +56,7 @@ Bot:   Given your preference for Rust in systems work, I'd lean that way —
 
 #### Consolidation
 
-When the active item count for a user crosses a threshold (`DISCOCLAW_DURABLE_CONSOLIDATION_THRESHOLD`, default `100`), consolidation can be triggered to prune and merge the list. A single `fast`-tier model call receives all active items and is asked to return a revised list — removing exact duplicates, merging near-duplicates, dropping clearly stale items, and preserving everything that is still plausibly useful. The model must not invent new facts or change the meaning of existing ones.
+When the active item count for a user crosses a threshold (`DISCOCLAW_DURABLE_CONSOLIDATION_THRESHOLD`, default `100`), consolidation can be triggered to prune and merge the list. A single `fast`-tier model call receives all active items and is asked to return a revised list — removing exact duplicates, merging near-duplicates, dropping clearly stale items, and preserving everything that is still plausibly useful. The model must not invent new facts or change the meaning of existing ones. Items with low `hitCount` and stale `lastHitAt` are natural eviction candidates — the blended score surfaces which items the AI actually uses versus those that were added once and never referenced again.
 
 The revised list is applied atomically: items absent from the model's output are deprecated via `deprecateItems()`; new or rewritten items are written via `addItem()`. Items present verbatim in the output are left untouched (no unnecessary writes).
 
@@ -183,7 +186,7 @@ no separator). The three memory builders run in `Promise.all` so they add no lat
 
 | Layer | Default budget | Default state | How it stays within budget |
 |-------|---------------|---------------|---------------------------|
-| Durable memory | 2000 chars | on | Sorts active items by recency, adds one at a time, stops when next line would exceed budget. Older facts silently excluded. |
+| Durable memory | 2000 chars | on | Ranks active items by blended score (recency + hit frequency), adds one at a time, stops when next line would exceed budget. Low-scoring items silently excluded. |
 | Rolling summary | 2000 chars | on | The `fast`-tier model is prompted with `"Keep the summary under {maxChars} characters"`. Replaces itself each update rather than growing. |
 | Message history | 3000 chars | on | Fetches up to 10 messages, walks backward from newest. Bot messages truncated to fit; user messages that don't fit cause a hard stop. |
 | Short-term memory | 1000 chars | **on** | Filters by max age (default 6h), sorts newest-first, accumulates lines until budget hit. |
@@ -202,7 +205,7 @@ might add ~500 chars total. Sections with no data produce zero overhead.
 
 ### Where the budgets are enforced
 
-- **Durable**: `selectItemsForInjection()` in `durable-memory.ts:152`
+- **Durable**: `selectItemsForInjection()` in `durable-memory.ts:152` — scores items using `hitCount`, `lastHitAt`, and `updatedAt`; increments hit counters on selected items
 - **Short-term**: `selectEntriesForInjection()` in `shortterm-memory.ts:113`
 - **Summary**: `fast`-tier prompt constraint in `summarizer.ts:63`
 - **History**: `fetchMessageHistory()` in `message-history.ts:38`

package/dist/cron/chain.js

@@ -0,0 +1,5 @@
+"use strict";
+// This file has been intentionally removed.
+// Chain logic lives directly in executor.ts (fireChainedJobs) and
+// actions-crons.ts (parseAndValidateChain, detectChainCycle).
+// See: ws-1077 audit fix.

package/dist/cron/chain.test.js

@@ -0,0 +1,226 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fireChainedJobs } from './executor.js';
+import { loadRunStats } from './run-stats.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function mockLog() {
+    return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+let tmpDir;
+beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'chain-test-'));
+});
+afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 3 });
+});
+async function makeStatsStore() {
+    return loadRunStats(path.join(tmpDir, 'stats.json'));
+}
+function makeDownstreamJob(cronId, threadId) {
+    return {
+        id: threadId,
+        cronId,
+        threadId,
+        guildId: 'guild-1',
+        name: `Job ${cronId}`,
+        def: { triggerType: 'schedule', schedule: '0 0 * * *', timezone: 'UTC', channel: 'general', prompt: 'test' },
+        cron: null,
+        running: false,
+    };
+}
+function makeMinimalCtx(statsStore, overrides) {
+    return {
+        client: {},
+        runtime: { id: 'claude_code', capabilities: new Set(), async *invoke() { } },
+        model: 'haiku',
+        cwd: '/tmp',
+        tools: [],
+        timeoutMs: 30_000,
+        status: null,
+        log: mockLog(),
+        discordActionsEnabled: false,
+        actionFlags: {
+            channels: false, messaging: false, guild: false, moderation: false,
+            polls: false, tasks: false, crons: false, botProfile: false,
+            forge: false, plan: false, memory: false, config: false, defer: false, voice: false,
+        },
+        statsStore,
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// fireChainedJobs
+// ---------------------------------------------------------------------------
+describe('fireChainedJobs', () => {
+    it('does nothing when getSchedulerJob is not set', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: ['downstream'] });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        const ctx = makeMinimalCtx(store);
+        // No getSchedulerJob → early return
+        await fireChainedJobs('upstream', ctx);
+        const rec = store.getRecord('downstream');
+        // State should NOT have been forwarded
+        expect(rec?.state).toBeUndefined();
+    });
+    it('does nothing when statsStore is not set', async () => {
+        const ctx = makeMinimalCtx(undefined, { statsStore: undefined });
+        // Should not throw
+        await fireChainedJobs('upstream', ctx);
+    });
+    it('does nothing when the upstream job has no chain', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', {});
+        const getSchedulerJob = vi.fn();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob });
+        await fireChainedJobs('upstream', ctx);
+        expect(getSchedulerJob).not.toHaveBeenCalled();
+    });
+    it('does nothing when chain is empty array', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: [] });
+        const getSchedulerJob = vi.fn();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob });
+        await fireChainedJobs('upstream', ctx);
+        expect(getSchedulerJob).not.toHaveBeenCalled();
+    });
+    it('forwards __upstream state to downstream job', async () => {
+        const store = await makeStatsStore();
+        const upstreamState = { lastSeenTag: 'v2.3.1', items: [1, 2, 3] };
+        await store.upsertRecord('upstream', 'thread-up', {
+            chain: ['downstream'],
+            state: upstreamState,
+        });
+        await store.upsertRecord('downstream', 'thread-down', {
+            state: { existingKey: 'preserved' },
+        });
+        const downstreamJob = makeDownstreamJob('downstream', 'thread-down');
+        const getSchedulerJob = vi.fn().mockReturnValue(downstreamJob);
+        const ctx = makeMinimalCtx(store, { getSchedulerJob });
+        await fireChainedJobs('upstream', ctx);
+        const rec = store.getRecord('downstream');
+        expect(rec?.state).toEqual({
+            existingKey: 'preserved',
+            __upstream: { fromCronId: 'upstream', state: upstreamState },
+        });
+    });
+    it('forwards empty state as __upstream when upstream has no state', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: ['downstream'] });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        const downstreamJob = makeDownstreamJob('downstream', 'thread-down');
+        const getSchedulerJob = vi.fn().mockReturnValue(downstreamJob);
+        const ctx = makeMinimalCtx(store, { getSchedulerJob });
+        await fireChainedJobs('upstream', ctx);
+        const rec = store.getRecord('downstream');
+        expect(rec?.state).toEqual({
+            __upstream: { fromCronId: 'upstream', state: {} },
+        });
+    });
+    it('skips downstream when record is not found', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: ['nonexistent'] });
+        const getSchedulerJob = vi.fn();
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log });
+        await fireChainedJobs('upstream', ctx);
+        expect(getSchedulerJob).not.toHaveBeenCalled();
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'nonexistent' }), expect.stringContaining('record not found'));
+    });
+    it('skips downstream when scheduler job is not found', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: ['downstream'] });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        const getSchedulerJob = vi.fn().mockReturnValue(undefined);
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log });
+        await fireChainedJobs('upstream', ctx);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'downstream' }), expect.stringContaining('scheduler job not found'));
+    });
+    it('fires multiple downstream jobs independently', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', {
+            chain: ['down-a', 'down-b'],
+            state: { data: 42 },
+        });
+        await store.upsertRecord('down-a', 'thread-a', {});
+        await store.upsertRecord('down-b', 'thread-b', {});
+        const jobA = makeDownstreamJob('down-a', 'thread-a');
+        const jobB = makeDownstreamJob('down-b', 'thread-b');
+        const getSchedulerJob = vi.fn((threadId) => {
+            if (threadId === 'thread-a')
+                return jobA;
+            if (threadId === 'thread-b')
+                return jobB;
+            return undefined;
+        });
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log });
+        await fireChainedJobs('upstream', ctx);
+        // Both should have __upstream state forwarded
+        const recA = store.getRecord('down-a');
+        const recB = store.getRecord('down-b');
+        expect(recA?.state?.__upstream).toEqual({ fromCronId: 'upstream', state: { data: 42 } });
+        expect(recB?.state?.__upstream).toEqual({ fromCronId: 'upstream', state: { data: 42 } });
+        // Both should have been logged as fired
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'down-a' }), expect.stringContaining('downstream fired'));
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'down-b' }), expect.stringContaining('downstream fired'));
+    });
+    it('logs warning and skips downstream when chain depth >= 10', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', { chain: ['downstream'] });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        const getSchedulerJob = vi.fn();
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log, chainDepth: 10 });
+        await fireChainedJobs('upstream', ctx);
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ cronId: 'upstream', chainDepth: 10 }), expect.stringContaining('depth limit'));
+        // getSchedulerJob should never be called — we returned early
+        expect(getSchedulerJob).not.toHaveBeenCalled();
+    });
+    it('increments chain depth for downstream execution context', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', {
+            chain: ['downstream'],
+            state: { x: 1 },
+        });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        const downstreamJob = makeDownstreamJob('downstream', 'thread-down');
+        const getSchedulerJob = vi.fn().mockReturnValue(downstreamJob);
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log, chainDepth: 5 });
+        await fireChainedJobs('upstream', ctx);
+        // The function should have fired (depth 5 < 10)
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'downstream' }), expect.stringContaining('downstream fired'));
+    });
+    it('handles state forward failure gracefully', async () => {
+        const store = await makeStatsStore();
+        await store.upsertRecord('upstream', 'thread-up', {
+            chain: ['downstream'],
+            state: { data: 1 },
+        });
+        await store.upsertRecord('downstream', 'thread-down', {});
+        // Mock upsertRecord to fail on state forwarding
+        const originalUpsert = store.upsertRecord.bind(store);
+        let callCount = 0;
+        vi.spyOn(store, 'upsertRecord').mockImplementation(async (...args) => {
+            callCount++;
+            // Fail on the state-forwarding call (the one during fireChainedJobs)
+            if (callCount > 0)
+                throw new Error('disk full');
+            return originalUpsert(...args);
+        });
+        const downstreamJob = makeDownstreamJob('downstream', 'thread-down');
+        const getSchedulerJob = vi.fn().mockReturnValue(downstreamJob);
+        const log = mockLog();
+        const ctx = makeMinimalCtx(store, { getSchedulerJob, log });
+        await fireChainedJobs('upstream', ctx);
+        // Should log a warning but still fire downstream
+        expect(log.warn).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'downstream' }), expect.stringContaining('state forward failed'));
+        expect(log.info).toHaveBeenCalledWith(expect.objectContaining({ downstream: 'downstream' }), expect.stringContaining('downstream fired'));
+    });
+});

package/dist/cron/cron-prompt.js

@@ -12,8 +12,12 @@
  * Expand {{channel}} and {{channelId}} placeholders in a cron prompt template.
  * All occurrences are replaced; unrecognized placeholders are left intact.
  */
-export function expandCronPlaceholders(text, channel, channelId) {
-    return text.replaceAll('{{channel}}', channel).replaceAll('{{channelId}}', channelId);
+export function expandCronPlaceholders(text, channel, channelId, state) {
+    const stateJson = JSON.stringify(state ?? {});
+    return text
+        .replaceAll('{{channel}}', channel)
+        .replaceAll('{{channelId}}', channelId)
+        .replaceAll('{{state}}', stateJson);
 }
 // ---------------------------------------------------------------------------
 // Prompt body builder
@@ -29,8 +33,8 @@ export function expandCronPlaceholders(text, channel, channelId) {
  *  - Silent-mode sentinel instruction
  */
 export function buildCronPromptBody(input) {
-    const { jobName, promptTemplate, channel, channelId = '', silent, routingMode, availableChannels, } = input;
-    const expandedPrompt = expandCronPlaceholders(promptTemplate, channel, channelId);
+    const { jobName, promptTemplate, channel, channelId = '', silent, routingMode, availableChannels, state, } = input;
+    const expandedPrompt = expandCronPlaceholders(promptTemplate, channel, channelId, state);
     const segments = [
         `You are executing a scheduled cron job named "${jobName}".`,
         `Instruction: ${expandedPrompt}`,
@@ -49,6 +53,24 @@ export function buildCronPromptBody(input) {
             segments.push('IMPORTANT: If there is nothing actionable to report, respond with exactly `HEARTBEAT_OK` and nothing else.');
         }
     }
+    // Inject persistent state section when state is present and non-empty.
+    if (state && Object.keys(state).length > 0) {
+        const STATE_CHAR_LIMIT = 4000;
+        let serialized = JSON.stringify(state, null, 2);
+        if (serialized.length > STATE_CHAR_LIMIT) {
+            serialized = serialized.slice(0, STATE_CHAR_LIMIT) + '\n... (state truncated)';
+        }
+        segments.push([
+            '## Persistent State',
+            '',
+            'The following state was persisted from your previous run:',
+            '```json',
+            serialized,
+            '```',
+            'If you need to update the persisted state for the next run, emit a `<cron-state>{...}</cron-state>` block ' +
+                'containing a JSON object with the full updated state. The emitted object fully replaces the existing state — include all keys you want to keep. Only emit this block if the state needs to change.',
+        ].join('\n'));
+    }
     return segments.join('\n\n');
 }
 // ---------------------------------------------------------------------------

package/dist/cron/cron-prompt.test.js

@@ -242,3 +242,81 @@ describe('buildCronPromptBody — placeholder expansion', () => {
         expect(body).toContain('Channel alerts with ID ch-5.');
     });
 });
+// ---------------------------------------------------------------------------
+// expandCronPlaceholders — {{state}} placeholder
+// ---------------------------------------------------------------------------
+describe('expandCronPlaceholders — {{state}} placeholder', () => {
+    it('expands {{state}} to JSON string of provided state', () => {
+        const result = expandCronPlaceholders('Current state: {{state}}', 'general', 'ch-1', { counter: 3, lastSeen: '2026-02-28' });
+        expect(result).toContain('"counter":3');
+        expect(result).toContain('"lastSeen":"2026-02-28"');
+        expect(result).not.toContain('{{state}}');
+    });
+    it('expands {{state}} to empty object JSON when state is undefined', () => {
+        const result = expandCronPlaceholders('State: {{state}}', 'general', 'ch-1');
+        expect(result).toBe('State: {}');
+    });
+    it('expands {{state}} to empty object JSON when state is empty', () => {
+        const result = expandCronPlaceholders('State: {{state}}', 'general', 'ch-1', {});
+        expect(result).toBe('State: {}');
+    });
+});
+// ---------------------------------------------------------------------------
+// buildCronPromptBody — persistent state
+// ---------------------------------------------------------------------------
+describe('buildCronPromptBody — persistent state', () => {
+    it('includes Persistent State section when state is non-empty', () => {
+        const body = buildCronPromptBody({
+            jobName: 'Stateful Job',
+            promptTemplate: 'Check for updates.',
+            channel: 'general',
+            state: { lastCheck: '2026-02-27', items: [1, 2, 3] },
+        });
+        expect(body).toContain('## Persistent State');
+        expect(body).toContain('"lastCheck": "2026-02-27"');
+        expect(body).toContain('<cron-state>');
+    });
+    it('omits Persistent State section when state is undefined', () => {
+        const body = buildCronPromptBody({
+            jobName: 'Stateless Job',
+            promptTemplate: 'Say hello.',
+            channel: 'general',
+        });
+        expect(body).not.toContain('Persistent State');
+        expect(body).not.toContain('<cron-state>');
+    });
+    it('omits Persistent State section when state is empty object', () => {
+        const body = buildCronPromptBody({
+            jobName: 'Empty State Job',
+            promptTemplate: 'Say hello.',
+            channel: 'general',
+            state: {},
+        });
+        expect(body).not.toContain('Persistent State');
+        expect(body).not.toContain('<cron-state>');
+    });
+    it('truncates very large state objects', () => {
+        const largeState = {};
+        for (let i = 0; i < 500; i++) {
+            largeState[`key_${i}`] = 'x'.repeat(20);
+        }
+        const body = buildCronPromptBody({
+            jobName: 'Large State Job',
+            promptTemplate: 'Process data.',
+            channel: 'general',
+            state: largeState,
+        });
+        expect(body).toContain('## Persistent State');
+        expect(body).toContain('(state truncated)');
+    });
+    it('includes cron-state emit instruction in the state section', () => {
+        const body = buildCronPromptBody({
+            jobName: 'Job',
+            promptTemplate: 'Do stuff.',
+            channel: 'general',
+            state: { v: 1 },
+        });
+        expect(body).toContain('<cron-state>');
+        expect(body).toContain('update');
+    });
+});

package/dist/cron/executor.js

@@ -20,6 +20,50 @@ async function recordError(ctx, job, msg) {
         }
     }
 }
+const MAX_CHAIN_DEPTH = 10;
+export async function fireChainedJobs(cronId, ctx) {
+    const chainDepth = ctx.chainDepth ?? 0;
+    if (chainDepth >= MAX_CHAIN_DEPTH) {
+        ctx.log?.warn({ cronId, chainDepth }, 'chain:depth limit reached, skipping downstream');
+        return;
+    }
+    if (!ctx.statsStore || !ctx.getSchedulerJob)
+        return;
+    const record = ctx.statsStore.getRecord(cronId);
+    if (!record?.chain || record.chain.length === 0)
+        return;
+    const upstreamState = record.state;
+    for (const downstreamCronId of record.chain) {
+        const downstreamRecord = ctx.statsStore.getRecord(downstreamCronId);
+        if (!downstreamRecord) {
+            ctx.log?.warn({ cronId, downstream: downstreamCronId }, 'chain:downstream record not found, skipping');
+            continue;
+        }
+        const downstreamJob = ctx.getSchedulerJob(downstreamRecord.threadId);
+        if (!downstreamJob) {
+            ctx.log?.warn({ cronId, downstream: downstreamCronId, threadId: downstreamRecord.threadId }, 'chain:downstream scheduler job not found, skipping');
+            continue;
+        }
+        // Merge __upstream into downstream job's persisted state so the prompt's {{state}} includes handoff data.
+        try {
+            const forwardedState = {
+                ...(downstreamRecord.state ?? {}),
+                __upstream: { fromCronId: cronId, state: upstreamState ?? {} },
+            };
+            await ctx.statsStore.upsertRecord(downstreamCronId, downstreamRecord.threadId, { state: forwardedState });
+            ctx.log?.info({ cronId, downstream: downstreamCronId }, 'chain:state forwarded');
+        }
+        catch (err) {
+            ctx.log?.warn({ err, cronId, downstream: downstreamCronId }, 'chain:state forward failed');
+        }
+        // Fire-and-forget with incremented chain depth.
+        const downstreamCtx = { ...ctx, chainDepth: chainDepth + 1 };
+        void executeCronJob(downstreamJob, downstreamCtx).catch((err) => {
+            ctx.log?.warn({ err, cronId, downstream: downstreamCronId }, 'chain:downstream execution failed');
+        });
+        ctx.log?.info({ cronId, downstream: downstreamCronId }, 'chain:downstream fired');
+    }
+}
 export async function executeCronJob(job, ctx) {
     const metrics = globalMetrics;
     let cancelRequested = false;
@@ -110,6 +154,7 @@ export async function executeCronJob(job, ctx) {
                 channelId: channelForSend.id,
                 silent: preRunRecord?.silent,
                 routingMode: preRunRecord?.routingMode === 'json' ? 'json' : undefined,
+                state: preRunRecord?.state,
             });
         const tools = await resolveEffectiveTools({
             workspaceCwd: ctx.cwd,
@@ -208,7 +253,31 @@ export async function executeCronJob(job, ctx) {
         }
         metrics.recordInvokeResult('cron', Date.now() - t0, true);
         ctx.log?.info({ flow: 'cron', jobId: job.id, ms: Date.now() - t0, ok: true }, 'obs.invoke.end');
-        const output = finalText || deltaText;
+        let output = finalText || deltaText;
+        // Extract <cron-state> blocks from the output — last one wins.
+        const cronStateRegex = /<cron-state>([\s\S]*?)<\/cron-state>/g;
+        let cronStateMatch;
+        let lastCronStateJson;
+        while ((cronStateMatch = cronStateRegex.exec(output)) !== null) {
+            lastCronStateJson = cronStateMatch[1];
+        }
+        if (lastCronStateJson !== undefined && ctx.statsStore && job.cronId) {
+            try {
+                const parsedState = JSON.parse(lastCronStateJson.trim());
+                if (parsedState && typeof parsedState === 'object' && !Array.isArray(parsedState)) {
+                    await ctx.statsStore.upsertRecord(job.cronId, job.threadId, { state: parsedState });
+                    ctx.log?.info({ jobId: job.id, cronId: job.cronId }, 'cron:exec persisted updated state');
+                }
+                else {
+                    ctx.log?.warn({ jobId: job.id, cronId: job.cronId }, 'cron:exec <cron-state> was not a JSON object, ignoring');
+                }
+            }
+            catch (stateErr) {
+                ctx.log?.warn({ err: stateErr, jobId: job.id, cronId: job.cronId }, 'cron:exec <cron-state> parse failed, ignoring');
+            }
+            // Strip all <cron-state> blocks from the output text.
+            output = output.replace(/<cron-state>[\s\S]*?<\/cron-state>/g, '').trim();
+        }
         if (!output.trim() && collectedImages.length === 0) {
             metrics.increment('cron.run.skipped');
             ctx.log?.warn({ jobId: job.id }, 'cron:exec empty output');
@@ -219,6 +288,7 @@ export async function executeCronJob(job, ctx) {
                 catch {
                     // Best-effort.
                 }
+                void fireChainedJobs(job.cronId, ctx);
             }
             return;
         }
@@ -310,6 +380,7 @@ export async function executeCronJob(job, ctx) {
                 catch {
                     // Best-effort.
                 }
+                void fireChainedJobs(job.cronId, ctx);
             }
             metrics.increment('cron.run.success');
             return;
@@ -326,6 +397,7 @@ export async function executeCronJob(job, ctx) {
                 catch {
                     // Best-effort.
                 }
+                void fireChainedJobs(job.cronId, ctx);
             }
             metrics.increment('cron.run.success');
             return;
@@ -366,6 +438,7 @@ export async function executeCronJob(job, ctx) {
             catch (statsErr) {
                 ctx.log?.warn({ err: statsErr, jobId: job.id }, 'cron:exec stats record failed');
             }
+            void fireChainedJobs(job.cronId, ctx);
         }
     }
     catch (err) {

package/dist/cron/executor.test.js

@@ -1003,3 +1003,105 @@ describe('executeCronJob allowedActions filtering', () => {
         executeDiscordActionsSpy.mockRestore();
     });
 });
+// ---------------------------------------------------------------------------
+// <cron-state> extraction and persistence
+// ---------------------------------------------------------------------------
+describe('executeCronJob cron-state extraction', () => {
+    let statsDir;
+    beforeEach(async () => {
+        statsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'executor-cron-state-'));
+    });
+    afterEach(async () => {
+        await fs.rm(statsDir, { recursive: true, force: true });
+    });
+    it('extracts <cron-state> block and persists state via upsertRecord', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1');
+        const response = 'Here is the report.\n<cron-state>{"lastSeen":"2026-02-28","count":5}</cron-state>';
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(response) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const rec = statsStore.getRecord('cron-test0001');
+        expect(rec.state).toEqual({ lastSeen: '2026-02-28', count: 5 });
+    });
+    it('strips <cron-state> blocks from the output sent to Discord', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1');
+        const response = 'Report content here.\n<cron-state>{"v":1}</cron-state>';
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(response) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const guild = ctx.client.guilds.cache.get('guild-1');
+        const channel = guild.channels.cache.get('general');
+        expect(channel.send).toHaveBeenCalled();
+        const sentContent = channel.send.mock.calls[0][0].content;
+        expect(sentContent).not.toContain('<cron-state>');
+        expect(sentContent).toContain('Report content here.');
+    });
+    it('uses the last <cron-state> block when multiple are present', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1');
+        const response = [
+            'Part 1.',
+            '<cron-state>{"v":1}</cron-state>',
+            'Part 2.',
+            '<cron-state>{"v":2,"final":true}</cron-state>',
+        ].join('\n');
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(response) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const rec = statsStore.getRecord('cron-test0001');
+        expect(rec.state).toEqual({ v: 2, final: true });
+    });
+    it('ignores invalid JSON in <cron-state> block gracefully', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', { state: { old: true } });
+        const response = 'Output here.\n<cron-state>not valid json</cron-state>';
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(response) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        // State should remain unchanged after invalid parse.
+        const rec = statsStore.getRecord('cron-test0001');
+        expect(rec.state).toEqual({ old: true });
+        expect(ctx.log?.warn).toHaveBeenCalledWith(expect.objectContaining({ jobId: 'thread-1' }), 'cron:exec <cron-state> parse failed, ignoring');
+    });
+    it('ignores non-object JSON in <cron-state> block (e.g. array)', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1');
+        const response = 'Output here.\n<cron-state>[1,2,3]</cron-state>';
+        const ctx = makeCtx({ statsStore, runtime: makeMockRuntime(response) });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        const rec = statsStore.getRecord('cron-test0001');
+        expect(rec.state).toBeUndefined();
+        expect(ctx.log?.warn).toHaveBeenCalledWith(expect.objectContaining({ jobId: 'thread-1' }), 'cron:exec <cron-state> was not a JSON object, ignoring');
+    });
+    it('passes existing state to the prompt via preRunRecord', async () => {
+        const statsPath = path.join(statsDir, 'stats.json');
+        const statsStore = await loadRunStats(statsPath);
+        await statsStore.upsertRecord('cron-test0001', 'thread-1', {
+            state: { counter: 42, lastItem: 'xyz' },
+        });
+        let capturedPrompt = '';
+        const runtime = {
+            id: 'claude_code',
+            capabilities: new Set(['streaming_text']),
+            async *invoke(opts) {
+                capturedPrompt = opts.prompt;
+                yield { type: 'text_final', text: 'Done.' };
+                yield { type: 'done' };
+            },
+        };
+        const ctx = makeCtx({ statsStore, runtime });
+        const job = makeJob();
+        await executeCronJob(job, ctx);
+        expect(capturedPrompt).toContain('Persistent State');
+        expect(capturedPrompt).toContain('"counter": 42');
+        expect(capturedPrompt).toContain('"lastItem": "xyz"');
+    });
+});