discoclaw 0.1.5 → 0.1.8

package/.context/discord.md

@@ -91,7 +91,7 @@ Each action category has its own flag (only active when the master switch is `1`
 Notes:
 - `reactionPrompt` is gated by the MESSAGING flag — it is registered via `REACTION_PROMPT_ACTION_TYPES` only when `flags.messaging` is true (`src/discord/actions.ts:113`).
 - Config actions (`modelSet`, `modelShow`) have no separate env flag. They are always enabled when the master switch is on, hardcoded in `src/index.ts`.
-- `generateImage` requires `IMAGEGEN_API_KEY` to be set (any OpenAI-compatible image generation endpoint). Optional: `IMAGEGEN_BASE_URL` to point at a non-OpenAI provider. Defaults to the DALL-E 3 model at `https://api.openai.com/v1`.
+- `generateImage` supports two providers: **OpenAI** (models: `dall-e-3`, `gpt-image-1`) and **Gemini** (models: `imagen-4.0-generate-001`, `imagen-4.0-fast-generate-001`, `imagen-4.0-ultra-generate-001`). Provider is auto-detected from the model prefix (`dall-e-*`/`gpt-image-*` → openai, `imagen-*` → gemini) or set explicitly via the `provider` field. OpenAI provider uses `OPENAI_API_KEY` (required) and optional `OPENAI_BASE_URL`. Gemini provider uses `IMAGEGEN_GEMINI_API_KEY`. At least one key must be set when `DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1`. Default model is auto-detected: if only `IMAGEGEN_GEMINI_API_KEY` is set, defaults to `imagen-4.0-generate-001`; otherwise defaults to `dall-e-3`. Override with `IMAGEGEN_DEFAULT_MODEL`.
 
 Auto-follow-up: When query actions (channelList, channelInfo, threadListArchived, forumTagList, readMessages, fetchMessage, listPins, memberInfo, roleInfo, searchMessages, eventList, taskList, taskShow, cronList, cronShow, planList, planShow, memoryShow, modelShow, forgeStatus) succeed, DiscoClaw automatically re-invokes Claude with the results. This allows Claude to reason about query results without requiring the user to send a follow-up message. Controlled by `DISCOCLAW_ACTION_FOLLOWUP_DEPTH` (default `3`, `0` disables). Mutation-only responses do not trigger follow-ups. Trivially short follow-up responses (<50 chars with no actions) are suppressed.
 

package/.context/pa.md

@@ -14,7 +14,7 @@ For architecture details, see `.context/architecture.md`.
 | `SOUL.md` | Core personality and values | Every prompt |
 | `IDENTITY.md` | Name and vibe | Every prompt |
 | `USER.md` | Who you're helping | Every prompt |
-| `AGENTS.md` | Your personal rules and conventions | Scaffolded on setup; accessible via Read tool |
+| `AGENTS.md` | Your personal rules and conventions | Every prompt |
 | `TOOLS.md` | Available tools and integrations | Every prompt |
 | `HEARTBEAT.md` | Periodic self-check template | By cron |
 | `MEMORY.md` | Curated long-term memory | DM prompts |

package/.context/runtime.md

@@ -194,7 +194,7 @@ Both require `CLAUDE_OUTPUT_FORMAT=stream-json` for structured events.
 
 **Budget semantics:** For multi-turn sessions, budget accumulates across turns and cannot be reset mid-session. Recommend $5-10 for multi-turn.
 
-**Append system prompt:** When set, workspace PA files (SOUL.md, IDENTITY.md, USER.md, TOOLS.md) are skipped from the context file list (their content is already in the system prompt). PA context modules (`.context/pa.md`, `.context/pa-safety.md`) and channel-specific context are unaffected. **Note:** Do not set this on first run before `workspace/BOOTSTRAP.md` has been consumed — the skip logic also bypasses BOOTSTRAP.md loading.
+**Append system prompt:** When set, workspace PA files (SOUL.md, IDENTITY.md, USER.md, AGENTS.md, TOOLS.md) are skipped from the context file list (their content is already in the system prompt). PA context modules (`.context/pa.md`, `.context/pa-safety.md`) and channel-specific context are unaffected. **Note:** Do not set this on first run before `workspace/BOOTSTRAP.md` has been consumed — the skip logic also bypasses BOOTSTRAP.md loading.
 
 - **Session scanner** (`src/runtime/session-scanner.ts`): watches `~/.claude/projects/<escaped-cwd>/<session-id>.jsonl`, skips pre-existing content, degrades gracefully if the file never appears.
 - **Tool-aware queue** (`src/discord/tool-aware-queue.ts`): state machine that suppresses narration text before tools, shows human-readable activity labels (from `src/runtime/tool-labels.ts`), and streams the final answer after all tool use completes.

package/.env.example.full

@@ -58,6 +58,28 @@ DISCORD_ALLOW_USER_IDS=
 # Individual overrides (DISCOCLAW_SUMMARY_MODEL, etc.) still win when set.
 #DISCOCLAW_FAST_MODEL=fast
 
+# --- Tier model overrides ---
+# Override the concrete model resolved for any runtime × tier combination.
+# Format: DISCOCLAW_TIER_<RUNTIME>_<FAST|CAPABLE>=<model>
+# Unset = use the built-in default shown in the comments.
+# Concrete model names (e.g. sonnet, gpt-4o-mini) are passed through unchanged.
+#
+# Claude Code adapter (default: fast=haiku, capable=opus):
+#DISCOCLAW_TIER_CLAUDE_CODE_FAST=haiku
+#DISCOCLAW_TIER_CLAUDE_CODE_CAPABLE=opus
+#
+# Gemini CLI adapter (default: fast=gemini-2.5-flash, capable=gemini-2.5-pro):
+#DISCOCLAW_TIER_GEMINI_FAST=gemini-2.5-flash
+#DISCOCLAW_TIER_GEMINI_CAPABLE=gemini-2.5-pro
+#
+# OpenAI-compatible adapter (default: adapter-default for both tiers):
+#DISCOCLAW_TIER_OPENAI_FAST=gpt-4o-mini
+#DISCOCLAW_TIER_OPENAI_CAPABLE=gpt-4o
+#
+# Codex CLI adapter (default: adapter-default for both tiers):
+#DISCOCLAW_TIER_CODEX_FAST=
+#DISCOCLAW_TIER_CODEX_CAPABLE=
+
 # Output format for the Claude CLI. stream-json gives smoother streaming.
 #CLAUDE_OUTPUT_FORMAT=stream-json
 
@@ -314,12 +336,19 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 #DISCOCLAW_SESSION_SCANNING=1
 # Parse tool-use events during streaming for better progress reporting and stall suppression.
 #DISCOCLAW_TOOL_AWARE_STREAMING=1
-# Stream stall detection: kill one-shot process if no stdout/stderr for this long (ms). 0 = disabled.
+# Stream stall detection: kill one-shot process if no stdout/stderr for this long (ms). 0 = disabled. (default: 600000)
 #DISCOCLAW_STREAM_STALL_TIMEOUT_MS=120000
 # Progress stall timeout: alert after this many ms with no progress event (ms). 0 = disabled.
 #DISCOCLAW_PROGRESS_STALL_TIMEOUT_MS=300000
-# Stream stall warning: show user-visible warning in Discord after this many ms of no events. 0 = disabled.
+# Stream stall warning: show user-visible warning in Discord after this many ms of no events. 0 = disabled. (default: 300000)
 #DISCOCLAW_STREAM_STALL_WARNING_MS=60000
+# Post a brief "Done (Xm Ys)" completion notice as a new message after long-running runs finish.
+# Discord's unread indicator fires on new messages but not edits, so users who left the channel
+# while the bot was working will see an unread badge. Set to 0 to disable.
+#DISCOCLAW_COMPLETION_NOTIFY=1
+# Minimum elapsed time (ms) before a completion notice is sent. Runs shorter than this are
+# considered "fast" and don't need a notification. Default: 30000 (30 seconds).
+#DISCOCLAW_COMPLETION_NOTIFY_THRESHOLD_MS=30000
 
 # ----------------------------------------------------------
 # Plan & Forge — AI-assisted planning and implementation
@@ -411,3 +440,21 @@ DISCOCLAW_DISCORD_ACTIONS_DEFER=1
 # Chromium path for agent-browser. Only needed if the bundled browser
 # (from `agent-browser install`) doesn't work.
 #AGENT_BROWSER_EXECUTABLE_PATH=/usr/bin/chromium-browser
+
+# ----------------------------------------------------------
+# 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 Imagen.
+DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=0
+# API key for Gemini Imagen models (imagen-4.0-generate-001 and similar).
+# Leave unset to use OpenAI only.
+#IMAGEGEN_GEMINI_API_KEY=
+# Override the default image generation model. If unset, auto-detected:
+# only IMAGEGEN_GEMINI_API_KEY set → imagen-4.0-generate-001; otherwise → dall-e-3.
+# OpenAI models: dall-e-3, gpt-image-1
+# Gemini models: imagen-4.0-generate-001, imagen-4.0-fast-generate-001, imagen-4.0-ultra-generate-001
+#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.

package/README.md

@@ -4,7 +4,7 @@
 
 # DiscoClaw
 
-A personal AI orchestrator that turns Discord into a persistent workspace — built on three pillars: **Memory**, **Tasks**, and **Crons**.
+A personal AI orchestrator that turns Discord into a persistent workspace — built on three pillars: **Memory**, **Tasks**, and **Automations**.
 
 DiscoClaw is an orchestrator: it coordinates between a user interface (Discord), one or more AI runtimes (Claude Code, OpenAI, Codex), and local system resources — managing conversation state, task routing, scheduling, and tool access. The intelligence is rented; the coordination is owned.
 
@@ -39,11 +39,11 @@ A lightweight in-process task store that syncs bidirectionally with Discord foru
 - **Create from either side** — Ask your assistant in chat or use task commands
 - **Bidirectional sync** — Status, priority, and tags stay in sync between the task store and Discord threads
 - **Status emoji and auto-tagging** — Thread names show live status at a glance
-- **Discord actions** — Your assistant manages tasks through conversation: create channels, send messages, search history, run polls, and more
+- **Discord actions** — Your assistant manages tasks through conversation: create channels, send messages, search history, run polls, and more (see [docs/discord-actions.md](docs/discord-actions.md))
 
 **Why Discord fits:** forum threads = task cards, archive = done, thread names show live status.
 
-## Crons — the bot acts on its own
+## Automations — the bot acts on its own
 
 Recurring tasks defined as forum threads in plain language — no crontab, no separate scheduler UI.
 
@@ -56,7 +56,7 @@ Recurring tasks defined as forum threads in plain language — no crontab, no se
 
 ## How it works
 
-DiscoClaw orchestrates the flow between Discord and AI runtimes (Claude Code by default, with OpenAI, Codex, and OpenRouter adapters available via `PRIMARY_RUNTIME`). It doesn't contain intelligence itself — it decides *when* to call the AI, *what context* to give it, and *what to do* with the output. When you send a message, the orchestrator:
+DiscoClaw orchestrates the flow between Discord and AI runtimes (Claude Code by default, with Gemini, OpenAI, Codex, and OpenRouter adapters available via `PRIMARY_RUNTIME`). It doesn't contain intelligence itself — it decides *when* to call the AI, *what context* to give it, and *what to do* with the output. When you send a message, the orchestrator:
 
 1. Checks the user allowlist (fail-closed — empty list means respond to nobody)
 2. Assembles context: per-channel rules, conversation history, rolling summary, and durable memory
@@ -93,10 +93,11 @@ Author one recipe file for an integration, share it, then let another user's Dis
 - **Node.js >=20** — check with `node --version`
 - One primary runtime:
   - **Claude CLI** on your `PATH` — check with `claude --version` (see [Claude CLI docs](https://docs.anthropic.com/en/docs/claude-code) to install), or
+  - **Gemini CLI** on your `PATH` — check with `gemini --version`, or
   - **Codex CLI** on your `PATH` — check with `codex --version`, or
   - **OpenAI-compatible API key** via `OPENAI_API_KEY`, or
   - **OpenRouter API key** via `OPENROUTER_API_KEY` (access to many providers)
-- Runtime-specific access for your chosen provider (Anthropic plan/API credits for Claude, OpenAI access for Codex/OpenAI models)
+- Runtime-specific access for your chosen provider (Anthropic plan/API credits for Claude, Google account for Gemini, OpenAI access for Codex/OpenAI models)
 
 **Contributors (from source):**
 - Everything above, plus **pnpm** — enable via Corepack (`corepack enable`) or install separately
@@ -158,6 +159,14 @@ pnpm dev
 
 **Global install:**
 
+If DiscoClaw is running, update from Discord:
+
+```
+!update apply
+```
+
+Or from the command line:
+
 ```bash
 npm update -g discoclaw
 discoclaw install-daemon   # re-register the service after updating

package/dist/cli/index.js

@@ -16,6 +16,49 @@ switch (command) {
     case 'install-daemon':
         await runDaemonInstaller();
         break;
+    case 'update': {
+        const subcommand = process.argv[3];
+        const { isNpmManaged, getLocalVersion, getLatestNpmVersion, npmGlobalUpgrade } = await import('../npm-managed.js');
+        const npmMode = await isNpmManaged();
+        if (subcommand === 'apply') {
+            if (!npmMode) {
+                console.error('This instance is not npm-managed. Use the git-based workflow to update.');
+                process.exit(1);
+            }
+            console.log('Installing latest version from npm...');
+            const result = await npmGlobalUpgrade();
+            if (result.exitCode !== 0) {
+                const detail = (result.stderr || result.stdout).trim().slice(0, 500);
+                console.error(`npm install -g discoclaw failed:\n${detail}`);
+                process.exit(1);
+            }
+            console.log('Update complete. Restart discoclaw to run the new version.');
+        }
+        else if (subcommand === undefined) {
+            if (!npmMode) {
+                console.log('This instance is not npm-managed; update checking is not supported in this mode.');
+                break;
+            }
+            const installed = getLocalVersion();
+            const latest = await getLatestNpmVersion();
+            if (latest === null) {
+                console.error('Failed to fetch latest version from npm registry.');
+                process.exit(1);
+            }
+            if (installed === latest) {
+                console.log(`Already on latest version (${installed}).`);
+            }
+            else {
+                console.log(`Update available: ${installed} → ${latest}. Run \`discoclaw update apply\` to upgrade.`);
+            }
+        }
+        else {
+            console.error(`Unknown update subcommand: ${subcommand}\n`);
+            printHelp(version);
+            process.exit(1);
+        }
+        break;
+    }
     case '--version':
     case '-v':
         console.log(version);
@@ -38,6 +81,8 @@ function printHelp(ver) {
         `  install-daemon [--service-name <name>]  Register discoclaw as a persistent background service\n` +
         `                                          Use --service-name to run multiple instances side-by-side.\n` +
         `                                          Defaults to "discoclaw".\n` +
+        `  update                                Check for available updates (npm-managed installs only)\n` +
+        `  update apply                          Install the latest version from npm and print restart reminder\n` +
         `\nOptions:\n` +
         `  -v, --version   Print version\n` +
         `  -h, --help      Print this help\n`);

package/dist/cli/init-wizard.js

@@ -105,8 +105,7 @@ export async function runInitWizard() {
         console.error('discoclaw init requires an interactive terminal.\n');
         process.exit(1);
     }
-    const cwd = process.cwd();
-    const envPath = path.join(cwd, '.env');
+    let cwd = process.cwd();
     let rl = null;
     let canceled = false;
     let completed = false;
@@ -163,8 +162,15 @@ export async function runInitWizard() {
         }
     }
     // ── Welcome ──────────────────────────────────────────────────────────────
-    console.log(`\nDiscoclaw Init\n==============\n` +
-        `This wizard creates a .env file and workspace/ directory in:\n  ${cwd}\n`);
+    console.log(`\nDiscoclaw Init\n==============`);
+    const installDirInput = await ask(`Install directory [${cwd}]: `);
+    if (installDirInput.trim()) {
+        cwd = path.resolve(installDirInput.trim());
+        if (!fs.existsSync(cwd)) {
+            fs.mkdirSync(cwd, { recursive: true });
+        }
+    }
+    console.log(`This wizard creates a .env file and workspace/ directory in:\n  ${cwd}\n`);
     // ── Discord bot guidance ──────────────────────────────────────────────────
     console.log(`Discord Bot Setup\n-----------------\n` +
         `If you haven't created a Discord bot yet, follow these steps:\n\n` +
@@ -188,6 +194,7 @@ export async function runInitWizard() {
     const values = {};
     values.DISCOCLAW_DATA_DIR = dataDir;
     // ── Check existing .env ───────────────────────────────────────────────────
+    const envPath = path.join(cwd, '.env');
     if (fs.existsSync(envPath)) {
         const existing = fs.readFileSync(envPath, 'utf8');
         const tokenMatch = existing.match(/^DISCORD_TOKEN=(.*)$/m);

package/dist/cli/init-wizard.test.js

@@ -153,6 +153,7 @@ describe('runInitWizard', () => {
         const previousCwd = process.cwd();
         const oldEnv = 'DISCORD_TOKEN=old.token.value\nDISCORD_ALLOW_USER_IDS=111111111111111111\n';
         const answers = [
+            '', // install directory (default)
             '', // Press Enter to continue
             '', // data directory (default cwd/data)
             'y', // Overwrite existing .env
@@ -193,6 +194,7 @@ describe('runInitWizard', () => {
         const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discoclaw-init-test-'));
         const previousCwd = process.cwd();
         const answers = [
+            '', // install directory (default)
             '', // Press Enter to continue
             '', // data directory (default cwd/data)
             // no existing .env
@@ -229,6 +231,7 @@ describe('runInitWizard', () => {
         const previousCwd = process.cwd();
         const customDataDir = path.join(tmpDir, 'my-data');
         const answers = [
+            '', // install directory (default)
             '', // Press Enter to continue
             customDataDir, // data directory (custom path)
             'a.b.c', // DISCORD_TOKEN
@@ -265,6 +268,7 @@ describe('runInitWizard', () => {
             'DISCOCLAW_CRON_FORUM=9000000000000000002',
         ].join('\n') + '\n';
         const answers = [
+            '', // install directory (default)
             '', // Press Enter to continue
             '', // data directory (default cwd/data)
             'y', // Overwrite existing .env
@@ -299,4 +303,54 @@ describe('runInitWizard', () => {
         const tasksIdx = newEnv.indexOf('DISCOCLAW_TASKS_FORUM=');
         expect(tasksIdx).toBeGreaterThan(autoDetectedIdx);
     });
+    it('uses a custom install directory when a path is provided', async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discoclaw-init-test-'));
+        const answers = [
+            tmpDir, // install directory (custom path)
+            '', // Press Enter to continue
+            '', // data directory (default)
+            'a.b.c', // DISCORD_TOKEN
+            '1000000000000000001', // DISCORD_ALLOW_USER_IDS
+            '', // provider selection -> default (Claude)
+            '', // enable skip permissions
+            '', // enable stream-json
+            'n', // configure recommended settings
+            'n', // configure optional features
+        ];
+        vi.mocked(createInterface).mockReturnValue(makeReadline(answers));
+        vi.mocked(execFileSync).mockImplementation(() => {
+            throw new Error('binary not found');
+        });
+        vi.mocked(ensureWorkspaceBootstrapFiles).mockResolvedValue([]);
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        await runInitWizard();
+        expect(fs.existsSync(path.join(tmpDir, '.env'))).toBe(true);
+        expect(ensureWorkspaceBootstrapFiles).toHaveBeenCalledWith(path.join(tmpDir, 'workspace'));
+    });
+    it('creates the install directory if it does not exist', async () => {
+        const baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'discoclaw-init-test-'));
+        const newDir = path.join(baseDir, 'new-subdir');
+        const answers = [
+            newDir, // install directory (non-existent path)
+            '', // Press Enter to continue
+            '', // data directory (default)
+            'a.b.c', // DISCORD_TOKEN
+            '1000000000000000001', // DISCORD_ALLOW_USER_IDS
+            '', // provider selection -> default (Claude)
+            '', // enable skip permissions
+            '', // enable stream-json
+            'n', // configure recommended settings
+            'n', // configure optional features
+        ];
+        vi.mocked(createInterface).mockReturnValue(makeReadline(answers));
+        vi.mocked(execFileSync).mockImplementation(() => {
+            throw new Error('binary not found');
+        });
+        vi.mocked(ensureWorkspaceBootstrapFiles).mockResolvedValue([]);
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        await runInitWizard();
+        expect(fs.existsSync(newDir)).toBe(true);
+        expect(fs.existsSync(path.join(newDir, '.env'))).toBe(true);
+        expect(ensureWorkspaceBootstrapFiles).toHaveBeenCalledWith(path.join(newDir, 'workspace'));
+    });
 });

package/dist/config.js

@@ -1,4 +1,4 @@
-import { parseAllowChannelIds, parseAllowUserIds } from './discord/allowlist.js';
+import { parseAllowBotIds, parseAllowChannelIds, parseAllowUserIds } from './discord/allowlist.js';
 export const KNOWN_TOOLS = new Set(['Bash', 'Read', 'Write', 'Edit', 'Glob', 'Grep', 'WebSearch', 'WebFetch']);
 export const DEFAULT_DISCORD_ACTIONS_DEFER_MAX_DELAY_SECONDS = 1800;
 export const DEFAULT_DISCORD_ACTIONS_DEFER_MAX_CONCURRENT = 5;
@@ -115,6 +115,12 @@ export function parseConfig(env) {
     else if (allowUserIds.size === 0) {
         warnings.push('DISCORD_ALLOW_USER_IDS is empty: bot will respond to nobody (fail closed)');
     }
+    const allowBotIdsRaw = env.DISCORD_ALLOW_BOT_IDS;
+    const allowBotIds = parseAllowBotIds(allowBotIdsRaw);
+    if ((allowBotIdsRaw ?? '').trim().length > 0 && allowBotIds.size === 0) {
+        warnings.push('DISCORD_ALLOW_BOT_IDS was set but no valid IDs were parsed: trusted-bot allowlist is empty');
+    }
+    const botMessageMemoryWriteEnabled = parseBoolean(env, 'DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE', false);
     const allowChannelIdsRaw = env.DISCORD_CHANNEL_IDS;
     const restrictChannelIds = (allowChannelIdsRaw ?? '').trim().length > 0;
     const allowChannelIds = parseAllowChannelIds(allowChannelIdsRaw);
@@ -196,6 +202,8 @@ export function parseConfig(env) {
     const openaiApiKey = parseTrimmedString(env, 'OPENAI_API_KEY');
     const openaiBaseUrl = parseTrimmedString(env, 'OPENAI_BASE_URL');
     const openaiModel = parseTrimmedString(env, 'OPENAI_MODEL') ?? 'gpt-4o';
+    const imagegenGeminiApiKey = parseTrimmedString(env, 'IMAGEGEN_GEMINI_API_KEY');
+    const imagegenDefaultModel = parseTrimmedString(env, 'IMAGEGEN_DEFAULT_MODEL');
     if (primaryRuntime === 'openai' && !openaiApiKey) {
         warnings.push('PRIMARY_RUNTIME=openai but OPENAI_API_KEY is not set; startup will fail unless another runtime is selected.');
     }
@@ -205,8 +213,16 @@ export function parseConfig(env) {
     if (forgeAuditorRuntime === 'openai' && !openaiApiKey) {
         warnings.push('FORGE_AUDITOR_RUNTIME=openai but OPENAI_API_KEY is not set; auditor will fall back to the primary runtime.');
     }
-    if (discordActionsImagegen && !openaiApiKey) {
-        warnings.push('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1 but OPENAI_API_KEY is not set; imagegen will fail at runtime.');
+    if (discordActionsImagegen && !openaiApiKey && !imagegenGeminiApiKey) {
+        warnings.push('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1 but neither OPENAI_API_KEY nor IMAGEGEN_GEMINI_API_KEY is set; imagegen will fail at runtime.');
+    }
+    if (imagegenDefaultModel) {
+        if (imagegenDefaultModel.startsWith('imagen-') && !imagegenGeminiApiKey) {
+            warnings.push(`IMAGEGEN_DEFAULT_MODEL="${imagegenDefaultModel}" requires IMAGEGEN_GEMINI_API_KEY but it is not set; imagegen will fail at runtime.`);
+        }
+        else if ((imagegenDefaultModel.startsWith('dall-e-') || imagegenDefaultModel.startsWith('gpt-image-')) && !openaiApiKey) {
+            warnings.push(`IMAGEGEN_DEFAULT_MODEL="${imagegenDefaultModel}" requires OPENAI_API_KEY but it is not set; imagegen will fail at runtime.`);
+        }
     }
     const openrouterApiKey = parseTrimmedString(env, 'OPENROUTER_API_KEY');
     const openrouterBaseUrl = parseTrimmedString(env, 'OPENROUTER_BASE_URL');
@@ -236,6 +252,8 @@ export function parseConfig(env) {
         config: {
             token,
             allowUserIds,
+            allowBotIds,
+            botMessageMemoryWriteEnabled,
             allowChannelIds,
             restrictChannelIds,
             primaryRuntime,
@@ -307,9 +325,13 @@ export function parseConfig(env) {
             forgeTimeoutMs: parsePositiveNumber(env, 'FORGE_TIMEOUT_MS', DEFAULT_THIRTY_MINUTES_MS),
             forgeProgressThrottleMs: parseNonNegativeInt(env, 'FORGE_PROGRESS_THROTTLE_MS', 3000),
             forgeAutoImplement: parseBoolean(env, 'FORGE_AUTO_IMPLEMENT', true),
+            completionNotifyEnabled: parseBoolean(env, 'DISCOCLAW_COMPLETION_NOTIFY', true),
+            completionNotifyThresholdMs: parseNonNegativeInt(env, 'DISCOCLAW_COMPLETION_NOTIFY_THRESHOLD_MS', 30000),
             openaiApiKey,
             openaiBaseUrl,
             openaiModel,
+            imagegenGeminiApiKey,
+            imagegenDefaultModel,
             forgeDrafterRuntime,
             forgeAuditorRuntime,
             openrouterApiKey,
@@ -372,9 +394,9 @@ export function parseConfig(env) {
             multiTurnHangTimeoutMs: parsePositiveInt(env, 'DISCOCLAW_MULTI_TURN_HANG_TIMEOUT_MS', 60000),
             multiTurnIdleTimeoutMs: parsePositiveInt(env, 'DISCOCLAW_MULTI_TURN_IDLE_TIMEOUT_MS', 300000),
             multiTurnMaxProcesses: parsePositiveInt(env, 'DISCOCLAW_MULTI_TURN_MAX_PROCESSES', 5),
-            streamStallTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_STREAM_STALL_TIMEOUT_MS', 300000),
+            streamStallTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_STREAM_STALL_TIMEOUT_MS', 600000),
             progressStallTimeoutMs: parseNonNegativeInt(env, 'DISCOCLAW_PROGRESS_STALL_TIMEOUT_MS', 300000),
-            streamStallWarningMs: parseNonNegativeInt(env, 'DISCOCLAW_STREAM_STALL_WARNING_MS', 150000),
+            streamStallWarningMs: parseNonNegativeInt(env, 'DISCOCLAW_STREAM_STALL_WARNING_MS', 300000),
             maxConcurrentInvocations: parseNonNegativeInt(env, 'DISCOCLAW_MAX_CONCURRENT_INVOCATIONS', 0),
             debugRuntime: parseBoolean(env, 'DISCOCLAW_DEBUG_RUNTIME', false),
             healthCommandsEnabled: parseBoolean(env, 'DISCOCLAW_HEALTH_COMMANDS_ENABLED', true),

package/dist/config.test.js

@@ -15,6 +15,8 @@ describe('parseConfig', () => {
         const { config, warnings, infos } = parseConfig(env());
         expect(config.token).toBe('token');
         expect(config.allowUserIds.has('123')).toBe(true);
+        expect(config.allowBotIds).toEqual(new Set());
+        expect(config.botMessageMemoryWriteEnabled).toBe(false);
         expect(config.primaryRuntime).toBe('claude');
         expect(config.runtimeModel).toBe('capable');
         expect(config.summaryModel).toBe('fast');
@@ -28,6 +30,44 @@ describe('parseConfig', () => {
         expect(warnings.some((w) => w.includes('category flags are ignored'))).toBe(false);
         expect(infos.some((i) => i.includes('category flags are ignored'))).toBe(false);
     });
+    // --- allowBotIds ---
+    it('defaults allowBotIds to empty set', () => {
+        const { config } = parseConfig(env());
+        expect(config.allowBotIds).toEqual(new Set());
+    });
+    it('parses DISCORD_ALLOW_BOT_IDS as a set of snowflakes', () => {
+        const { config } = parseConfig(env({ DISCORD_ALLOW_BOT_IDS: '111, 222 333' }));
+        expect(config.allowBotIds).toEqual(new Set(['111', '222', '333']));
+    });
+    it('drops non-numeric tokens from DISCORD_ALLOW_BOT_IDS', () => {
+        const { config } = parseConfig(env({ DISCORD_ALLOW_BOT_IDS: 'mybot 999' }));
+        expect(config.allowBotIds).toEqual(new Set(['999']));
+    });
+    it('returns empty set for allowBotIds when DISCORD_ALLOW_BOT_IDS is undefined', () => {
+        const { config } = parseConfig(env({ DISCORD_ALLOW_BOT_IDS: undefined }));
+        expect(config.allowBotIds).toEqual(new Set());
+    });
+    // --- botMessageMemoryWriteEnabled ---
+    it('defaults botMessageMemoryWriteEnabled to false', () => {
+        const { config } = parseConfig(env());
+        expect(config.botMessageMemoryWriteEnabled).toBe(false);
+    });
+    it('sets botMessageMemoryWriteEnabled to true when DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE=true', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE: 'true' }));
+        expect(config.botMessageMemoryWriteEnabled).toBe(true);
+    });
+    it('sets botMessageMemoryWriteEnabled to true when DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE=1', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE: '1' }));
+        expect(config.botMessageMemoryWriteEnabled).toBe(true);
+    });
+    it('leaves botMessageMemoryWriteEnabled false when DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE=false', () => {
+        const { config } = parseConfig(env({ DISCOCLAW_BOT_MESSAGE_MEMORY_WRITE: 'false' }));
+        expect(config.botMessageMemoryWriteEnabled).toBe(false);
+    });
+    it('emits a warning when DISCORD_ALLOW_BOT_IDS is set but yields no valid IDs', () => {
+        const { warnings } = parseConfig(env({ DISCORD_ALLOW_BOT_IDS: 'not-a-snowflake' }));
+        expect(warnings.some((w) => w.includes('DISCORD_ALLOW_BOT_IDS was set but no valid IDs were parsed'))).toBe(true);
+    });
     it('throws on invalid boolean values', () => {
         expect(() => parseConfig(env({ DISCOCLAW_SUMMARY_ENABLED: 'yes' })))
             .toThrow(/DISCOCLAW_SUMMARY_ENABLED must be "0"\/"1" or "true"\/"false"/);
@@ -203,14 +243,58 @@ describe('parseConfig', () => {
         }));
         expect(infos.some((i) => i.includes('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN'))).toBe(true);
     });
-    it('warns when discordActionsImagegen is enabled but OPENAI_API_KEY is unset', () => {
-        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '1', OPENAI_API_KEY: undefined }));
+    it('warns when discordActionsImagegen is enabled but neither key is set', () => {
+        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '1', OPENAI_API_KEY: undefined, IMAGEGEN_GEMINI_API_KEY: undefined }));
         expect(warnings.some((w) => w.includes('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1'))).toBe(true);
     });
+    it('does not warn about imagegen key when OPENAI_API_KEY is set', () => {
+        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '1', OPENAI_API_KEY: 'sk-test', IMAGEGEN_GEMINI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1'))).toBe(false);
+    });
+    it('does not warn about imagegen key when IMAGEGEN_GEMINI_API_KEY is set', () => {
+        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '1', OPENAI_API_KEY: undefined, IMAGEGEN_GEMINI_API_KEY: 'gemini-key' }));
+        expect(warnings.some((w) => w.includes('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1'))).toBe(false);
+    });
     it('does not warn about imagegen key when discordActionsImagegen is disabled', () => {
-        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '0', OPENAI_API_KEY: undefined }));
+        const { warnings } = parseConfig(env({ DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN: '0', OPENAI_API_KEY: undefined, IMAGEGEN_GEMINI_API_KEY: undefined }));
         expect(warnings.some((w) => w.includes('DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1'))).toBe(false);
     });
+    it('parses IMAGEGEN_GEMINI_API_KEY when set', () => {
+        const { config } = parseConfig(env({ IMAGEGEN_GEMINI_API_KEY: 'gemini-key' }));
+        expect(config.imagegenGeminiApiKey).toBe('gemini-key');
+    });
+    it('returns undefined for imagegenGeminiApiKey when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.imagegenGeminiApiKey).toBeUndefined();
+    });
+    it('parses IMAGEGEN_DEFAULT_MODEL when set', () => {
+        const { config } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'imagen-4.0-generate-002', IMAGEGEN_GEMINI_API_KEY: 'gemini-key' }));
+        expect(config.imagegenDefaultModel).toBe('imagen-4.0-generate-002');
+    });
+    it('returns undefined for imagegenDefaultModel when unset', () => {
+        const { config } = parseConfig(env());
+        expect(config.imagegenDefaultModel).toBeUndefined();
+    });
+    it('warns when IMAGEGEN_DEFAULT_MODEL is an imagen-* model but IMAGEGEN_GEMINI_API_KEY is unset', () => {
+        const { warnings } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'imagen-4.0-generate-002', IMAGEGEN_GEMINI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('IMAGEGEN_DEFAULT_MODEL') && w.includes('IMAGEGEN_GEMINI_API_KEY'))).toBe(true);
+    });
+    it('warns when IMAGEGEN_DEFAULT_MODEL is a dall-e-* model but OPENAI_API_KEY is unset', () => {
+        const { warnings } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'dall-e-3', OPENAI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('IMAGEGEN_DEFAULT_MODEL') && w.includes('OPENAI_API_KEY'))).toBe(true);
+    });
+    it('warns when IMAGEGEN_DEFAULT_MODEL is a gpt-image-* model but OPENAI_API_KEY is unset', () => {
+        const { warnings } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'gpt-image-1', OPENAI_API_KEY: undefined }));
+        expect(warnings.some((w) => w.includes('IMAGEGEN_DEFAULT_MODEL') && w.includes('OPENAI_API_KEY'))).toBe(true);
+    });
+    it('does not warn about IMAGEGEN_DEFAULT_MODEL when imagen-* and IMAGEGEN_GEMINI_API_KEY is set', () => {
+        const { warnings } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'imagen-4.0-generate-002', IMAGEGEN_GEMINI_API_KEY: 'gemini-key' }));
+        expect(warnings.some((w) => w.includes('IMAGEGEN_DEFAULT_MODEL'))).toBe(false);
+    });
+    it('does not warn about IMAGEGEN_DEFAULT_MODEL when dall-e-* and OPENAI_API_KEY is set', () => {
+        const { warnings } = parseConfig(env({ IMAGEGEN_DEFAULT_MODEL: 'dall-e-3', OPENAI_API_KEY: 'sk-test' }));
+        expect(warnings.some((w) => w.includes('IMAGEGEN_DEFAULT_MODEL'))).toBe(false);
+    });
     it('defaults sessionScanning to true', () => {
         const { config } = parseConfig(env());
         expect(config.sessionScanning).toBe(true);
@@ -535,13 +619,13 @@ describe('parseConfig', () => {
         expect(warnings).toContainEqual(expect.stringContaining('CLAUDE_VERBOSE=1 ignored'));
     });
     // --- Stream stall detection ---
-    it('defaults streamStallTimeoutMs to 300000', () => {
+    it('defaults streamStallTimeoutMs to 600000', () => {
         const { config } = parseConfig(env());
-        expect(config.streamStallTimeoutMs).toBe(300000);
+        expect(config.streamStallTimeoutMs).toBe(600000);
     });
-    it('defaults streamStallWarningMs to 150000', () => {
+    it('defaults streamStallWarningMs to 300000', () => {
         const { config } = parseConfig(env());
-        expect(config.streamStallWarningMs).toBe(150000);
+        expect(config.streamStallWarningMs).toBe(300000);
     });
     it('parses custom streamStallTimeoutMs', () => {
         const { config } = parseConfig(env({ DISCOCLAW_STREAM_STALL_TIMEOUT_MS: '30000' }));

package/dist/cron/executor.js

@@ -49,6 +49,15 @@ export async function executeCronJob(job, ctx) {
     job.running = true;
     ctx.runControl?.register(job.id, requestCancel);
     try {
+        // Best-effort: write running status to persistent store before execution begins.
+        if (ctx.statsStore && job.cronId) {
+            try {
+                await ctx.statsStore.recordRunStart(job.cronId);
+            }
+            catch {
+                // Non-fatal — don't block execution.
+            }
+        }
         // Resolve the target channel from the job's owning guild.
         const guild = ctx.client.guilds.cache.get(job.guildId);
         if (!guild) {
@@ -195,6 +204,14 @@ export async function executeCronJob(job, ctx) {
         if (!output.trim() && collectedImages.length === 0) {
             metrics.increment('cron.run.skipped');
             ctx.log?.warn({ jobId: job.id }, 'cron:exec empty output');
+            if (ctx.statsStore && job.cronId) {
+                try {
+                    await ctx.statsStore.recordRun(job.cronId, 'success');
+                }
+                catch {
+                    // Best-effort.
+                }
+            }
             return;
         }
         let processedText = output;
@@ -223,6 +240,7 @@ export async function executeCronJob(job, ctx) {
                     forgeCtx: ctx.forgeCtx,
                     planCtx: ctx.planCtx,
                     memoryCtx: ctx.memoryCtx,
+                    imagegenCtx: ctx.imagegenCtx,
                 });
                 for (const result of results) {
                     metrics.recordActionResult(result.ok);