discoclaw 0.7.0 → 0.8.0

package/.context/runtime.md

@@ -77,6 +77,50 @@ Shutdown: `killAllSubprocesses()` from `cli-adapter.ts` kills all tracked subpro
   - `CLAUDE_OUTPUT_FORMAT=stream-json` (preferred; DiscoClaw parses JSONL and streams text)
   - `CLAUDE_OUTPUT_FORMAT=text` (fallback if your local CLI doesn't support stream-json)
 
+## Codex CLI Runtime
+
+- Adapter: `src/runtime/codex-cli.ts` (thin wrapper around `cli-adapter.ts` + `strategies/codex-strategy.ts`)
+- Default transport:
+  - The default Codex path is `codex exec` / `codex exec resume`.
+  - DiscoClaw currently prefers the CLI route for reliability, especially in forge flows.
+- Optional native transport:
+  - When explicitly enabled, DiscoClaw can use the Codex app-server websocket for `thread/start`, `turn/start`, streaming output, `turn/steer`, and `turn/interrupt`.
+  - The native path still uses Codex's local app-server auth/session state, so no public API key is required.
+- Activation and fallback:
+  - Native invoke is opt-in via `CODEX_APP_SERVER_NATIVE=1`.
+  - Native invoke also requires `CODEX_APP_SERVER_URL` to point at a reachable websocket endpoint.
+  - If the native flag is off, the URL is unset, or the turn hits an images / non-default `cwd` bypass gate, DiscoClaw uses the `codex exec` / `codex exec resume` transport instead.
+  - If native invoke is selected but the websocket connection cannot be established, DiscoClaw falls back to `codex exec` for that turn rather than failing closed.
+- Env vars:
+  | Var | Default | Purpose |
+  |-----|---------|---------|
+  | `CODEX_APP_SERVER_NATIVE` | `0` | Enables the app-server-native invoke path for eligible turns. |
+  | `CODEX_APP_SERVER_URL` | *(unset)* | Codex app-server websocket URL (for example `ws://127.0.0.1:4321`) used by the native path. |
+- Native bypass gates:
+  - **Images:** turns with `images` bypass native invoke and stay on `codex exec`, because image parity is not guaranteed on the app-server path.
+  - **Non-default `cwd`:** turns whose `cwd` differs from the process working directory bypass native invoke and stay on `codex exec`, which is the only path that can shape the subprocess working directory per turn.
+  - **`addDirs`:** native invoke passes extra readable roots through to the app-server sandbox as additional `readableRoots`, so standard Discord turns can still stay on the websocket path.
+  - **Connection failure:** if the runtime cannot connect/initialize against the app-server websocket, it immediately drops back to `codex exec` for that invocation.
+- Capability declaration:
+  - When native invoke is enabled and the app-server is configured, the runtime adds `mid_turn_steering` and exposes `RuntimeAdapter.steer()` + `RuntimeAdapter.interrupt()`.
+  - When native invoke is inactive, the Codex adapter behaves like the legacy CLI runtime: no control methods and no extra capability.
+- Lifecycle and streaming:
+  - For native turns, the runtime creates or reuses a thread with `thread/start`, starts the turn with `turn/start`, and tracks the active turn directly from the app-server response/notifications.
+  - Streaming reply text comes from agent-message delta/completed notifications; tool progress comes from item start/completion notifications; terminal turn notifications clear the active turn and finish the stream.
+  - Because the runtime receives the live `turnId` from the app-server itself, steering and interrupt can target the active turn reliably instead of depending on `codex exec --json` to surface it mid-turn.
+- Session semantics:
+  - Reusing the same `sessionKey` reuses the same native `threadId`, so repeated turns continue the same Codex thread.
+  - Omitting `sessionKey` creates an ephemeral native thread for that invocation only.
+  - `disableSessions` strips `sessionKey` before dispatch, so native turns become ephemeral and never reuse a prior thread.
+- Steering / interrupt semantics:
+  - `steer(sessionKey, message)` is best-effort and returns `false` instead of throwing when there is no tracked active turn or the app-server request fails.
+  - Successful steering sends `turn/steer` with `threadId` plus `expectedTurnId`; if the server returns a replacement `turnId`, the runtime updates its active-turn pointer.
+  - `interrupt(sessionKey)` is also best-effort and sends `turn/interrupt` with the active `threadId` + `turnId`, then clears local active-turn state.
+- Tradeoffs vs `codex exec`:
+  - Native invoke is useful when live control matters: it owns thread/turn lifecycle directly, exposes the active `turnId`, and supports steer/interrupt semantics.
+  - `codex exec` remains the default and preferred path for general reliability, plus any turns that need unsupported invocation shapes or when the app-server is unavailable.
+  - Keeping both paths preserves local Codex auth and session behavior without forcing the app-server path on day-to-day usage.
+
 ## Gemini CLI Runtime
 
 - Adapter: `src/runtime/gemini-cli.ts` (thin wrapper around `cli-adapter.ts` + `strategies/gemini-strategy.ts`)

package/.env.example

@@ -91,6 +91,8 @@ DISCORD_GUILD_ID=
 #DISCOCLAW_CODEX_ITEM_TYPE_DEBUG=1
 # Log each Discord preview line decision (allowed/suppressed + rendered line) to journald:
 #DISCOCLAW_DEBUG_STREAM_PREVIEW_LINES=1
+# Discord action auto-follow-up stall timeout (ms). Controls when pending follow-up turns are treated as stalled.
+#DISCOCLAW_ACTION_FOLLOWUP_TIMEOUT_MS=30000
 
 # [DEPRECATED] Model configuration has moved to models.json (managed via !models commands).
 # RUNTIME_MODEL is still read as a fallback when models.json is missing, but new deployments

package/.env.example.full

@@ -437,6 +437,8 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 #DISCOCLAW_MAX_CONCURRENT_INVOCATIONS=3
 # Max depth for chained action follow-ups (e.g. defer → action → response). 0 = disabled.
 #DISCOCLAW_ACTION_FOLLOWUP_DEPTH=3
+# Timeout (ms) before a pending Discord action auto-follow-up is marked stalled. Default: 30000.
+#DISCOCLAW_ACTION_FOLLOWUP_TIMEOUT_MS=30000
 # Timeout for runtime invocations (ms).
 #RUNTIME_TIMEOUT_MS=1800000
 # Global runtime supervisor wrapper (off by default; preserves legacy behavior).
@@ -524,9 +526,13 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # ----------------------------------------------------------
 # Route the forge drafter to a non-Claude runtime.
 # Valid values: "codex" (Codex CLI), "openai" (OpenAI-compatible HTTP API), "openrouter" (OpenRouter).
+# Note: forge currently forces Codex phases onto codex exec by default instead of
+# the native app-server path.
 #FORGE_DRAFTER_RUNTIME=
 # Route the forge auditor to a non-Claude runtime.
 # Valid values: "codex" (Codex CLI), "openai" (OpenAI-compatible HTTP API), "openrouter" (OpenRouter).
+# Note: forge currently forces Codex phases onto codex exec by default instead of
+# the native app-server path.
 #FORGE_AUDITOR_RUNTIME=
 
 # --- Codex CLI adapter ---
@@ -534,6 +540,20 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 #CODEX_BIN=codex
 # Optional: isolate Codex state/sessions from ~/.codex (helps avoid stale rollout DB issues).
 #CODEX_HOME=/absolute/path/to/.codex-home-discoclaw
+# Optional: Codex app-server websocket URL for the native app-server invoke path.
+# When combined with CODEX_APP_SERVER_NATIVE=1, DiscoClaw uses the websocket for
+# thread/turn lifecycle, streaming output, steering, and interrupts. Unset keeps
+# the native path dormant.
+#CODEX_APP_SERVER_URL=ws://127.0.0.1:4321
+# Enable the optional native Codex app-server transport.
+# Set to 1 to allow eligible Codex turns to use the websocket path. The CLI route
+# remains the recommended default for normal ops because it has been more reliable.
+# Image turns, non-default cwd turns, and websocket bootstrap failures fall back
+# to codex exec automatically. Forge currently disables the native app-server
+# route for Codex phases by default and uses codex exec instead; CODEX_APP_SERVER_NATIVE=1
+# still applies to other eligible Codex turns. Extra readable roots from addDirs
+# are passed through to the app-server sandbox.
+#CODEX_APP_SERVER_NATIVE=0
 # Default model for the Codex CLI adapter. Used when FORGE_AUDITOR_MODEL is not set.
 #CODEX_MODEL=gpt-5.4
 # WARNING: disables Codex approval prompts and sandbox protections (full-access mode).
@@ -593,8 +613,17 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # ----------------------------------------------------------
 # Image generation
 # ----------------------------------------------------------
-# Master switch — enables the imagegen Discord action category (default: off).
-# When enabled, the AI can generate images via action blocks using OpenAI or Gemini.
+# Discoverable by default on the normal user-facing help/manual surfaces:
+# `!models`, `!models help`, and the normal manual message/follow-up action path
+# can advertise `imagegen` before setup is complete.
+# `!models` shows `imagegen` as setup-required when unconfigured; `!models help`
+# points operators back to env setup because `!models set` does not configure imagegen.
+# Master switch for actual image generation execution (default: off).
+# When set to 1 and a provider key is configured, the AI can generate images via
+# action blocks using OpenAI or Gemini. When left at 0, normal manual/follow-up
+# invocations return a setup walkthrough instead of generating an image.
+# Reaction/deferred advertisement rules remain on their existing flag-driven contract,
+# and loop execution does not use the manual setup walkthrough path.
 DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=0
 # API key for Gemini image generation (Imagen and native Gemini models).
 # Leave unset to use OpenAI only.
@@ -606,8 +635,9 @@ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=0
 # Gemini native models (text+image in one call): gemini-3.1-flash-image-preview, gemini-3-pro-image-preview
 #IMAGEGEN_DEFAULT_MODEL=
 # Note: OpenAI image generation reuses OPENAI_API_KEY (documented above in the
-# OpenAI-compatible HTTP adapter section). When DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1,
-# at least one of OPENAI_API_KEY or IMAGEGEN_GEMINI_API_KEY must be set.
+# OpenAI-compatible HTTP adapter section). Actual generation stays disabled until
+# DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1 and at least one of OPENAI_API_KEY or
+# IMAGEGEN_GEMINI_API_KEY is set.
 
 # ----------------------------------------------------------
 # Voice (STT/TTS) — join voice channels, listen and respond

package/dist/cli/dashboard.js

@@ -7,7 +7,7 @@ import { config as loadDotenv } from 'dotenv';
 import { getLocalVersion, isNpmManaged } from '../npm-managed.js';
 import { isModelTier, listKnownModelValues } from '../runtime/model-tiers.js';
 import { getGitHash } from '../version.js';
-import { applyFixes, inspect, KNOWN_RUNTIMES, loadDoctorContext } from '../health/config-doctor.js';
+import { applyFixes, inspect, KNOWN_RUNTIMES, loadDoctorContext, updateEnvKey } from '../health/config-doctor.js';
 import { detectMcpServers, validateMcpEnvInterpolation, validateMcpServerEnv, validateMcpServerNames, } from '../mcp-detect.js';
 import { DEFAULTS as MODEL_DEFAULTS, saveModelConfig } from '../model-config.js';
 import { saveOverrides } from '../runtime-overrides.js';
@@ -59,6 +59,7 @@ function createDefaultDeps() {
         loadDoctorContext,
         saveModelConfig,
         saveOverrides,
+        updateEnvKey,
         runCommand(cmd, args) {
             return new Promise((resolve) => {
                 execFile(cmd, args, { timeout: 15_000 }, (err, stdout, stderr) => {
@@ -311,6 +312,7 @@ export async function collectDashboardSnapshot(opts = {}, deps = createDefaultDe
         },
         mcpStatus: toBootReportMcpStatus(mcpDetectResult),
         mcpWarnings,
+        primaryRuntime: normalizeRuntimeName(ctx.env.PRIMARY_RUNTIME) ?? 'claude',
     };
 }
 export function renderDashboard(snapshot, detail = '') {

package/dist/cli/dashboard.test.js

@@ -22,6 +22,7 @@ function makeConfigPaths(cwd, dataDir = path.join(cwd, 'data')) {
 function makeDoctorContext(overrides = {}) {
     return {
         cwd: '/repo',
+        workspaceCwd: '/repo/workspace',
         installMode: 'source',
         env: {
             DISCOCLAW_SERVICE_NAME: 'discoclaw-beta',
@@ -103,6 +104,7 @@ function makeDashboardDeps(overrides = {}) {
         loadDoctorContext: vi.fn(async () => makeDoctorContext()),
         saveModelConfig: vi.fn(async () => undefined),
         saveOverrides: vi.fn(async () => undefined),
+        updateEnvKey: vi.fn(async () => undefined),
         runCommand: vi.fn(async () => ({
             stdout: 'Active: active (running)\n',
             stderr: '',
@@ -148,6 +150,7 @@ function makeSnapshot(overrides = {}) {
         },
         mcpStatus: { status: 'missing' },
         mcpWarnings: 0,
+        primaryRuntime: 'claude',
         ...overrides,
     };
 }
@@ -270,6 +273,7 @@ describe('collectDashboardSnapshot', () => {
             loadDoctorContext: vi.fn(async () => ctx),
             saveModelConfig: vi.fn(async () => undefined),
             saveOverrides: vi.fn(async () => undefined),
+            updateEnvKey: vi.fn(async () => undefined),
             runCommand: vi.fn(async () => ({
                 stdout: '   Active: active (running) since today\n',
                 stderr: '',
@@ -287,6 +291,7 @@ describe('collectDashboardSnapshot', () => {
         expect(snapshot.doctorSummary).toBe('1 findings (errors=1, warnings=0, info=0)');
         expect(snapshot.version).toBe('1.2.3');
         expect(snapshot.gitHash).toBe('abc1234');
+        expect(snapshot.primaryRuntime).toBe('claude');
         expect(snapshot.roles).toEqual([
             'chat',
             'plan-run',
@@ -328,6 +333,7 @@ describe('collectDashboardSnapshot', () => {
             loadDoctorContext,
             saveModelConfig: vi.fn(async () => undefined),
             saveOverrides: vi.fn(async () => undefined),
+            updateEnvKey: vi.fn(async () => undefined),
             runCommand: vi.fn(async () => ({
                 stdout: '   Active: active (running) since today\n',
                 stderr: '',

package/dist/config.js

@@ -481,6 +481,7 @@ export function parseConfig(env) {
             forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', true),
             completionNotifyEnabled: parseBoolean(env, 'DISCOCLAW_COMPLETION_NOTIFY', true),
             completionNotifyThresholdMs: parseNonNegativeInt(env, 'DISCOCLAW_COMPLETION_NOTIFY_THRESHOLD_MS', 30000),
+            actionFollowupTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_ACTION_FOLLOWUP_TIMEOUT_MS', 30000),
             openaiApiKey,
             openaiBaseUrl,
             openaiModel,

package/dist/cron/cron-sync-coordinator.test.js

@@ -11,6 +11,7 @@ vi.mock('./cron-sync.js', () => ({
         statusMessagesUpdated: 1,
         promptMessagesCreated: 0,
         orphansDetected: 0,
+        projectionsRepaired: 0,
     })),
 }));
 import { reloadCronTagMapInPlace } from './tag-map.js';
@@ -41,7 +42,7 @@ describe('CronSyncCoordinator', () => {
         vi.resetAllMocks();
         mockReload.mockResolvedValue(2);
         mockRunCronSync.mockResolvedValue({
-            tagsApplied: 1, namesUpdated: 0, statusMessagesUpdated: 1, promptMessagesCreated: 0, orphansDetected: 0,
+            tagsApplied: 1, namesUpdated: 0, statusMessagesUpdated: 1, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0,
         });
     });
     it('reloads tag map before sync when tagMapPath is set', async () => {
@@ -70,7 +71,7 @@ describe('CronSyncCoordinator', () => {
     it('coalesced concurrent sync returns null', async () => {
         let resolveSync;
         mockRunCronSync.mockImplementation(() => new Promise((resolve) => {
-            resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0 });
+            resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0 });
         }));
         const coordinator = new CronSyncCoordinator(makeOpts());
         const first = coordinator.sync();
@@ -86,10 +87,10 @@ describe('CronSyncCoordinator', () => {
         mockRunCronSync.mockImplementation(() => new Promise((resolve) => {
             callCount++;
             if (callCount === 1) {
-                resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0 });
+                resolveSync = () => resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0 });
             }
             else {
-                resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0 });
+                resolve({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0 });
             }
         }));
         const coordinator = new CronSyncCoordinator(makeOpts());

package/dist/cron/cron-sync.js

@@ -1,5 +1,5 @@
 import { EmbedBuilder } from 'discord.js';
-import { CADENCE_TAGS } from './run-stats.js';
+import { CADENCE_TAGS, computeDefinitionHash } from './run-stats.js';
 import { detectCadence } from './cadence.js';
 import { autoTagCron, classifyCronModel } from './auto-tag.js';
 import { buildCronThreadName, ensureStatusMessage, resolveForumChannel } from './discord-sync.js';
@@ -25,7 +25,7 @@ export async function runCronSync(opts) {
     const forum = await resolveForumChannel(client, forumId);
     if (!forum) {
         log?.warn({ forumId }, 'cron-sync: forum not found');
-        return { tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0 };
+        return { tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0 };
     }
     const tagMap = opts.tagMap;
     const purposeTags = purposeTagNames(tagMap);
@@ -34,6 +34,7 @@ export async function runCronSync(opts) {
     let statusMessagesUpdated = 0;
     let promptMessagesCreated = 0;
     let orphansDetected = 0;
+    let projectionsRepaired = 0;
     const asEditableCronThread = (value) => {
         if (!value || typeof value !== 'object')
             return null;
@@ -46,13 +47,15 @@ export async function runCronSync(opts) {
             return null;
         }
         const appliedTags = Array.isArray(t.appliedTags) ? t.appliedTags.filter((id) => typeof id === 'string') : undefined;
+        const sourceThread = value;
         return {
             id: t.id,
             parentId: t.parentId,
             name: t.name,
             appliedTags,
-            edit: t.edit,
-            setName: t.setName,
+            // Discord.js thread mutators read `this.client.rest`, so keep the live thread instance as `this`.
+            edit: t.edit.bind(sourceThread),
+            setName: t.setName.bind(sourceThread),
         };
     };
     // Get all active threads in the forum.
@@ -168,6 +171,15 @@ export async function runCronSync(opts) {
         try {
             await ensureStatusMessage(client, fullJob.threadId, fullJob.cronId, record, statsStore, { log });
             statusMessagesUpdated++;
+            // Update projection hash after successful status message sync.
+            const currentHash = computeDefinitionHash(record);
+            if (record.projectionHash !== currentHash || record.projectionStatus !== 'synced') {
+                await statsStore.upsertRecord(fullJob.cronId, fullJob.threadId, {
+                    projectionStatus: 'synced',
+                    projectionSyncedAt: new Date().toISOString(),
+                    projectionHash: currentHash,
+                });
+            }
         }
         catch (err) {
             log?.warn({ err, jobId: job.id }, 'cron-sync:phase3 status message failed');
@@ -231,6 +243,103 @@ export async function runCronSync(opts) {
             log?.warn({ threadId: editableThread.id, name: editableThread.name }, 'cron-sync:phase4 orphan thread (no registered job)');
         }
     }
-    log?.info({ tagsApplied, namesUpdated, statusMessagesUpdated, promptMessagesCreated, orphansDetected }, 'cron-sync: complete');
-    return { tagsApplied, namesUpdated, statusMessagesUpdated, promptMessagesCreated, orphansDetected };
+    // Phase 5: Projection reconciliation — repair missing/drifted/stale Discord projections
+    // from canonical local state. This ensures local records are the source of truth.
+    const allRecords = statsStore.getCanonicalDefinitions();
+    for (const [cronId, record] of Object.entries(allRecords)) {
+        const currentHash = computeDefinitionHash(record);
+        const status = record.projectionStatus;
+        const needsReconciliation = status === 'missing' ||
+            status === 'drifted' ||
+            status === 'pending-resync' ||
+            (record.projectionHash !== undefined && record.projectionHash !== currentHash);
+        if (!needsReconciliation)
+            continue;
+        if (status === 'missing') {
+            // Thread was deleted — recreate from canonical definition.
+            if (!record.channel || !record.prompt)
+                continue;
+            try {
+                const baseName = record.prompt.slice(0, 50).replace(/\n/g, ' ').trim() || cronId;
+                const cadence = record.cadence ?? null;
+                const threadName = buildCronThreadName(baseName, cadence);
+                const starterContent = [
+                    `**Schedule:** \`${record.schedule ?? 'N/A'}\``,
+                    `**Timezone:** ${record.timezone ?? 'UTC'}`,
+                    `**Channel:** ${record.channel}`,
+                    `**Prompt:** ${record.prompt}`,
+                    `\n[cronId:${cronId}]`,
+                ].join('\n');
+                const newThread = await forum.threads.create({
+                    name: threadName,
+                    message: { content: starterContent },
+                });
+                // Update the record with the new thread ID and mark synced.
+                await statsStore.upsertRecord(cronId, newThread.id, {
+                    projectionStatus: 'synced',
+                    projectionSyncedAt: new Date().toISOString(),
+                    projectionHash: currentHash,
+                    statusMessageId: undefined,
+                    promptMessageId: undefined,
+                });
+                // Re-register in scheduler from canonical definition.
+                // Clean up any stale scheduler entry first (e.g., from canonical orphan
+                // recovery at boot or threadDelete resilience — the cron may still be
+                // registered under the old/deleted thread ID).
+                const def = {
+                    triggerType: record.triggerType ?? 'schedule',
+                    schedule: record.schedule,
+                    timezone: record.timezone ?? 'UTC',
+                    channel: record.channel,
+                    prompt: record.prompt,
+                };
+                try {
+                    const staleJob = scheduler.getJobByCronId(cronId);
+                    if (staleJob && staleJob.id !== newThread.id) {
+                        scheduler.unregister(staleJob.id);
+                    }
+                    scheduler.register(newThread.id, newThread.id, forum.guildId, threadName, def, cronId);
+                    if (record.disabled)
+                        scheduler.disable(newThread.id);
+                }
+                catch {
+                    // Registration failed — will retry next sync cycle.
+                }
+                projectionsRepaired++;
+                log?.info({ cronId, newThreadId: newThread.id }, 'cron-sync:phase5 recreated missing projection');
+            }
+            catch (err) {
+                log?.warn({ err, cronId }, 'cron-sync:phase5 failed to recreate missing projection');
+            }
+            await sleep(throttleMs);
+        }
+        else {
+            // Drifted, pending-resync, or hash mismatch — update status message and mark synced.
+            // The status message content was already refreshed in Phase 3 for scheduler-registered
+            // jobs; for any remaining records, ensure the projection metadata is up to date.
+            try {
+                const liveRecord = statsStore.getRecord(cronId);
+                if (liveRecord) {
+                    try {
+                        await ensureStatusMessage(client, liveRecord.threadId, cronId, liveRecord, statsStore, { log });
+                    }
+                    catch {
+                        // Thread may not exist; status message update is best-effort.
+                    }
+                    await statsStore.upsertRecord(cronId, liveRecord.threadId, {
+                        projectionStatus: 'synced',
+                        projectionSyncedAt: new Date().toISOString(),
+                        projectionHash: currentHash,
+                    });
+                }
+                projectionsRepaired++;
+            }
+            catch (err) {
+                log?.warn({ err, cronId }, 'cron-sync:phase5 failed to reconcile drifted projection');
+            }
+            await sleep(throttleMs);
+        }
+    }
+    log?.info({ tagsApplied, namesUpdated, statusMessagesUpdated, promptMessagesCreated, orphansDetected, projectionsRepaired }, 'cron-sync: complete');
+    return { tagsApplied, namesUpdated, statusMessagesUpdated, promptMessagesCreated, orphansDetected, projectionsRepaired };
 }

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

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { ChannelType } from 'discord.js';
 import { runCronSync } from './cron-sync.js';
+import { buildCronThreadName } from './discord-sync.js';
 function makeMockRuntime(output) {
     return {
         id: 'other',
@@ -45,6 +46,15 @@ function makeStatsStore(records) {
         recordRun: vi.fn(async () => { }),
         removeRecord: vi.fn(async () => true),
         removeByThreadId: vi.fn(async () => true),
+        markProjectionMissing: vi.fn(async () => true),
+        markProjectionDrifted: vi.fn(async () => true),
+        queueResync: vi.fn(async () => true),
+        getCanonicalDefinitions: vi.fn(() => {
+            const snapshot = {};
+            for (const [id, rec] of Object.entries(store))
+                snapshot[id] = { ...rec };
+            return snapshot;
+        }),
     };
 }
 function makeScheduler(jobs) {
@@ -56,10 +66,39 @@ function makeScheduler(jobs) {
                 return undefined;
             return { id: j.id, cronId: j.cronId, threadId: j.threadId, guildId: 'g1', name: j.name, def: { schedule: j.schedule, timezone: 'UTC', channel: 'general', prompt: j.prompt }, cron: null, running: false };
         },
+        getJobByCronId: (cronId) => {
+            const j = jobs.find((jj) => jj.cronId === cronId);
+            if (!j)
+                return undefined;
+            return { id: j.id, cronId: j.cronId, threadId: j.threadId, guildId: 'g1', name: j.name, def: { schedule: j.schedule, timezone: 'UTC', channel: 'general', prompt: j.prompt }, cron: null, running: false };
+        },
+        register: vi.fn(),
+        unregister: vi.fn(),
+        disable: vi.fn(),
     };
 }
 function makeForum(threads) {
-    const threadMap = new Map(threads.map((t) => [t.id, { ...t, appliedTags: t.appliedTags ?? [], edit: vi.fn(), setName: vi.fn() }]));
+    const threadMap = new Map(threads.map((fixture) => {
+        const thread = {
+            id: fixture.id,
+            name: fixture.name,
+            parentId: fixture.parentId,
+            appliedTags: fixture.appliedTags ?? [],
+            client: fixture.client ?? { rest: {} },
+        };
+        thread.edit = fixture.edit ?? vi.fn(async function (payload) {
+            if (payload.appliedTags)
+                this.appliedTags = payload.appliedTags;
+            if (payload.name)
+                this.name = payload.name;
+            return this;
+        });
+        thread.setName = fixture.setName ?? vi.fn(async function (name) {
+            this.name = name;
+            return this;
+        });
+        return [thread.id, thread];
+    }));
     return {
         id: 'forum-1',
         type: ChannelType.GuildForum,
@@ -177,6 +216,78 @@ describe('runCronSync', () => {
         });
         expect(result.namesUpdated).toBe(1);
     });
+    it('phase 2: keeps setName bound to the live thread instance', async () => {
+        const expectedName = buildCronThreadName('Daily Check', 'daily');
+        const edit = vi.fn(async function (payload) {
+            void this.client.rest;
+            if (payload.name)
+                this.name = payload.name;
+            return this;
+        });
+        const setName = async function (name) {
+            return this.edit({ name });
+        };
+        const forum = makeForum([{ id: 'thread-2', name: 'Old Name', parentId: 'forum-1', edit, setName }]);
+        const client = makeClient(forum);
+        const log = mockLog();
+        const record = makeRecord({ cronId: 'cron-2', threadId: 'thread-2', cadence: 'daily', purposeTags: ['monitoring'], model: 'haiku' });
+        const scheduler = makeScheduler([{ id: 'thread-2', threadId: 'thread-2', cronId: 'cron-2', name: 'Daily Check', schedule: '0 7 * * *', prompt: 'Check things' }]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: false,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log,
+            throttleMs: 0,
+        });
+        expect(result.namesUpdated).toBe(1);
+        const thread = (await forum.threads.fetchActive()).threads.get('thread-2');
+        expect(thread.name).toBe(expectedName);
+        expect(edit).toHaveBeenCalledWith({ name: expectedName });
+        expect(log.warn).not.toHaveBeenCalledWith(expect.objectContaining({ threadId: 'thread-2' }), 'cron-sync:phase2 name update failed');
+    });
+    it('phase 1: keeps edit bound to the live thread instance', async () => {
+        const edit = vi.fn(async function (payload) {
+            void this.client.rest;
+            if (payload.appliedTags)
+                this.appliedTags = payload.appliedTags;
+            return this;
+        });
+        const forum = makeForum([{ id: 'thread-1', name: 'Test Job', parentId: 'forum-1', edit }]);
+        const client = makeClient(forum);
+        const log = mockLog();
+        const record = makeRecord({
+            cronId: 'cron-1',
+            threadId: 'thread-1',
+            cadence: 'daily',
+            purposeTags: ['monitoring'],
+            model: 'fast',
+        });
+        const scheduler = makeScheduler([{ id: 'thread-1', threadId: 'thread-1', cronId: 'cron-1', name: 'Test Job', schedule: '0 7 * * *', prompt: 'Monitor health' }]);
+        const result = await runCronSync({
+            client: client,
+            forumId: 'forum-1',
+            scheduler,
+            statsStore: makeStatsStore([record]),
+            runtime: makeMockRuntime('monitoring'),
+            tagMap: { ...defaultTagMap },
+            autoTag: true,
+            autoTagModel: 'haiku',
+            cwd: '/tmp',
+            log,
+            throttleMs: 0,
+        });
+        expect(result.tagsApplied).toBe(1);
+        const thread = (await forum.threads.fetchActive()).threads.get('thread-1');
+        expect(thread.appliedTags).toEqual(['tag-1', 'tag-3']);
+        expect(edit).toHaveBeenCalledWith({ appliedTags: ['tag-1', 'tag-3'] });
+        expect(log.warn).not.toHaveBeenCalledWith(expect.objectContaining({ threadId: 'thread-1' }), 'cron-sync:phase1 tag apply failed');
+    });
     it('continues with metadata/status phases when fetchActive fails', async () => {
         const forum = makeForum([]);
         forum.threads.fetchActive.mockRejectedValueOnce(new Error('Discord API failure'));

package/dist/cron/cron-tag-map-watcher.test.js

@@ -12,7 +12,7 @@ function mockLog() {
 }
 function makeCoordinator() {
     return {
-        sync: vi.fn(async () => ({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0 })),
+        sync: vi.fn(async () => ({ tagsApplied: 0, namesUpdated: 0, statusMessagesUpdated: 0, promptMessagesCreated: 0, orphansDetected: 0, projectionsRepaired: 0 })),
     };
 }
 describe('startCronTagMapWatcher', () => {

package/dist/cron/executor.js

@@ -9,6 +9,7 @@ import { ensureStatusMessage } from './discord-sync.js';
 import { globalMetrics } from '../observability/metrics.js';
 import { mapRuntimeErrorToUserMessage } from '../discord/user-errors.js';
 import { resolveModel } from '../runtime/model-tiers.js';
+import { resolveGroundedToolCapabilities } from '../runtime/tool-capabilities.js';
 import { buildCronPromptBody } from './cron-prompt.js';
 import { buildTieredDiscordActionsPromptSection } from '../discord/actions.js';
 import { handleJsonRouteOutput } from './json-router.js';
@@ -192,7 +193,12 @@ export async function executeCronJob(job, ctx) {
         const cronActionFlags = actionRequester.trusted
             ? ctx.actionFlags
             : withoutRequesterGatedActionFlags(ctx.actionFlags);
-        let prompt = buildPromptPreamble(inlinedContext) +
+        let prompt = buildPromptPreamble(inlinedContext, {
+            runtimeId: ctx.runtime.id,
+            runtimeCapabilities: ctx.runtime.capabilities,
+            runtimeTools: ctx.tools,
+            enableHybridPipeline: ctx.enableHybridPipeline,
+        }) +
             '\n\n' +
             buildCronPromptBody({
                 jobName: job.name,
@@ -213,7 +219,7 @@ export async function executeCronJob(job, ctx) {
         const tools = await resolveEffectiveTools({
             workspaceCwd: ctx.cwd,
             runtimeTools: ctx.tools,
-            runtimeCapabilities: ctx.runtime.capabilities,
+            runtimeCapabilities: resolveGroundedToolCapabilities(ctx.runtime),
             runtimeId: ctx.runtime.id,
             log: ctx.log,
         });