discoclaw 1.3.0 → 2.0.0

package/dist/health/config-doctor.js

@@ -13,7 +13,7 @@ export const KNOWN_RUNTIMES = new Set([
     'openai',
     'openrouter',
 ]);
-const KNOWN_RUNTIME_OVERRIDE_KEYS = new Set(['ttsVoice', 'voiceRuntime', 'fastRuntime']);
+const KNOWN_RUNTIME_OVERRIDE_KEYS = new Set(['voiceRuntime', 'fastRuntime']);
 const DEPRECATED_ENV_VARS = {
     DISCOCLAW_FAST_RUNTIME: {
         recommendation: "Replace DISCOCLAW_FAST_RUNTIME with '!models set fast <model>' and remove the env var once the runtime override is no longer needed.",
@@ -146,8 +146,6 @@ async function readRuntimeOverridesFileState(filePath) {
         }
         const obj = parsed;
         const overrides = {};
-        if (typeof obj['ttsVoice'] === 'string')
-            overrides.ttsVoice = obj['ttsVoice'];
         if (typeof obj['voiceRuntime'] === 'string')
             overrides.voiceRuntime = obj['voiceRuntime'];
         if (typeof obj['fastRuntime'] === 'string')
@@ -568,32 +566,12 @@ export function detectMissingSecrets(ctx) {
     }
     const voiceEnabled = parseBoolean(ctx.env.DISCOCLAW_VOICE_ENABLED, false);
     if (voiceEnabled) {
-        const sttProvider = trimValue(ctx.env.DISCOCLAW_STT_PROVIDER) ?? 'deepgram';
-        const ttsProvider = trimValue(ctx.env.DISCOCLAW_TTS_PROVIDER) ?? 'cartesia';
-        const voiceSecretTargets = [];
-        if (sttProvider === 'deepgram') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_STT_PROVIDER', provider: sttProvider, secretKey: 'DEEPGRAM_API_KEY' });
-        }
-        else if (sttProvider === 'openai') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_STT_PROVIDER', provider: sttProvider, secretKey: 'OPENAI_API_KEY' });
-        }
-        if (ttsProvider === 'cartesia') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'CARTESIA_API_KEY' });
-        }
-        else if (ttsProvider === 'deepgram') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'DEEPGRAM_API_KEY' });
-        }
-        else if (ttsProvider === 'openai') {
-            voiceSecretTargets.push({ label: 'DISCOCLAW_TTS_PROVIDER', provider: ttsProvider, secretKey: 'OPENAI_API_KEY' });
-        }
-        for (const target of voiceSecretTargets) {
-            if (hasSecret(ctx.env, target.secretKey))
-                continue;
+        if (!hasSecret(ctx.env, 'GEMINI_API_KEY')) {
             findings.push({
-                id: `missing-secret:${target.label}:${target.secretKey}`,
+                id: 'missing-secret:DISCOCLAW_VOICE_ENABLED:GEMINI_API_KEY',
                 severity: 'error',
-                message: `${target.label}=${target.provider} requires ${target.secretKey}, but it is not set.`,
-                recommendation: `Set ${target.secretKey} or switch ${target.label} to a provider that is already configured.`,
+                message: 'DISCOCLAW_VOICE_ENABLED=1 requires GEMINI_API_KEY, but it is not set.',
+                recommendation: 'Set GEMINI_API_KEY or disable voice on this install.',
                 autoFixable: false,
             });
         }

package/dist/health/config-doctor.test.js

@@ -242,8 +242,6 @@ describe('detectMissingSecrets', () => {
         await writeEnv(cwd, [
             'PRIMARY_RUNTIME=openrouter',
             'DISCOCLAW_VOICE_ENABLED=1',
-            'DISCOCLAW_STT_PROVIDER=deepgram',
-            'DISCOCLAW_TTS_PROVIDER=cartesia',
             'DISCOCLAW_COLD_STORAGE_ENABLED=1',
             'DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN=1',
             'IMAGEGEN_DEFAULT_MODEL=imagen-4.0-generate-001',
@@ -256,8 +254,7 @@ describe('detectMissingSecrets', () => {
         expect(findings.map((finding) => finding.id)).toEqual([
             'missing-secret:PRIMARY_RUNTIME:OPENROUTER_API_KEY',
             'missing-secret:runtime-overrides.voiceRuntime:OPENAI_API_KEY',
-            'missing-secret:DISCOCLAW_STT_PROVIDER:DEEPGRAM_API_KEY',
-            'missing-secret:DISCOCLAW_TTS_PROVIDER:CARTESIA_API_KEY',
+            'missing-secret:DISCOCLAW_VOICE_ENABLED:GEMINI_API_KEY',
             'missing-secret:DISCOCLAW_COLD_STORAGE_ENABLED:COLD_STORAGE_API_KEY-or-OPENAI_API_KEY',
             'missing-secret:DISCOCLAW_DISCORD_ACTIONS_IMAGEGEN:OPENAI_API_KEY-or-IMAGEGEN_GEMINI_API_KEY',
             'missing-secret:IMAGEGEN_DEFAULT_MODEL:IMAGEGEN_GEMINI_API_KEY',

package/dist/index.js

@@ -1105,9 +1105,6 @@ if (currentOverridesState.fastRuntime) {
         log.warn({ fastRuntime: currentOverridesState.fastRuntime, availableRuntimes: runtimeRegistry.list() }, 'runtime-overrides: fastRuntime is not a registered runtime; ignoring');
     }
 }
-if (currentOverridesState.ttsVoice) {
-    log.info({ ttsVoice: currentOverridesState.ttsVoice }, 'runtime-overrides: ttsVoice override will be applied');
-}
 // Track which roles have active file-backed overrides (used by !models show).
 // Only mark as override if the stored value differs from env defaults.
 const overrideSources = detectOverrideSources(currentModelConfig, envModelDefaults);
@@ -1261,8 +1258,6 @@ const botParams = {
     spawnCtx: undefined,
     voiceCtx: undefined,
     voiceStatusCtx: undefined,
-    setTtsVoice: undefined,
-    getTtsVoice: undefined,
     configCtx: undefined,
     deferOpts: undefined,
     messageHistoryBudget,
@@ -1325,13 +1320,8 @@ const botParams = {
     voiceEnabled: cfg.voiceEnabled,
     voiceAutoJoin: cfg.voiceAutoJoin,
     voiceModelCtx: voiceModelRef,
-    voiceSttProvider: cfg.voiceSttProvider,
-    voiceTtsProvider: cfg.voiceTtsProvider,
     voiceHomeChannel: cfg.voiceHomeChannel,
-    deepgramApiKey: cfg.deepgramApiKey,
-    deepgramSttModel: cfg.deepgramSttModel,
-    deepgramTtsVoice: cfg.deepgramTtsVoice,
-    cartesiaApiKey: cfg.cartesiaApiKey,
+    geminiApiKey: cfg.geminiApiKey,
     botStatus: cfg.botStatus,
     botActivity: cfg.botActivity,
     botActivityType: cfg.botActivityType,
@@ -2090,19 +2080,10 @@ if (taskCtx) {
             log,
             voiceConfig: {
                 enabled: cfg.voiceEnabled,
-                sttProvider: cfg.voiceSttProvider,
-                ttsProvider: cfg.voiceTtsProvider,
                 homeChannel: cfg.voiceHomeChannel,
-                deepgramApiKey: cfg.deepgramApiKey,
-                deepgramSttModel: cfg.deepgramSttModel,
-                deepgramTtsVoice: overrides.ttsVoice ?? cfg.deepgramTtsVoice,
-                deepgramTtsSpeed: cfg.deepgramTtsSpeed,
-                cartesiaApiKey: cfg.cartesiaApiKey,
-                openaiApiKey: cfg.openaiApiKey,
             },
             allowedUserIds: allowUserIds,
             createDecoder: opusDecoderFactory,
-            voiceProvider: cfg.voicePipelineProvider,
             geminiApiKey: cfg.geminiApiKey,
             enabledTools: runtimeTools,
             invokeAi: voiceInvokeAi,
@@ -2134,14 +2115,6 @@ if (taskCtx) {
             },
         });
         botParams.voiceStatusCtx = { voiceManager };
-        botParams.setTtsVoice = async (voice) => {
-            const count = await audioPipeline.setTtsVoice(voice);
-            botParams.deepgramTtsVoice = voice;
-            currentOverridesState.ttsVoice = voice;
-            saveOverrides(overridesPath, currentOverridesState).catch((err) => log.warn({ err, voice }, 'runtime-overrides: ttsVoice save failed'));
-            return count;
-        };
-        botParams.getTtsVoice = () => audioPipeline.ttsVoice;
         if (cfg.discordActionsVoice) {
             botParams.voiceCtx = { voiceManager };
             log.info('voice:action context initialized with audio pipeline');

package/dist/runtime-overrides.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { parseRuntimeNameForPlacement } from './runtime/runtime-path-contract.js';
 const OVERRIDES_FILENAME = 'runtime-overrides.json';
-const KNOWN_OVERRIDE_KEYS = ['ttsVoice', 'voiceRuntime', 'fastRuntime'];
+const KNOWN_OVERRIDE_KEYS = ['voiceRuntime', 'fastRuntime'];
 export function normalizeRuntimeOverrides(overrides) {
     const next = { ...overrides };
     let changed = false;
@@ -57,8 +57,6 @@ export async function loadOverrides(filePath, onWarn) {
     }
     const obj = parsed;
     const overrides = {};
-    if (typeof obj['ttsVoice'] === 'string')
-        overrides.ttsVoice = obj['ttsVoice'];
     if (typeof obj['voiceRuntime'] === 'string')
         overrides.voiceRuntime = obj['voiceRuntime'];
     if (typeof obj['fastRuntime'] === 'string')
@@ -75,6 +73,7 @@ export async function saveOverrides(filePath, overrides) {
     const tmpPath = `${filePath}.tmp.${process.pid}`;
     try {
         const preserved = await readExistingRawObject(filePath);
+        delete preserved['ttsVoice'];
         for (const key of KNOWN_OVERRIDE_KEYS) {
             delete preserved[key];
         }

package/dist/runtime-overrides.test.js

@@ -1,229 +1,63 @@
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import os from 'node:os';
+import path from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
-import { loadOverrides, normalizeRuntimeOverrides, resolveOverridesPath, saveOverrides, } from './runtime-overrides.js';
+import { loadOverrides, normalizeRuntimeOverrides, resolveOverridesPath, saveOverrides } from './runtime-overrides.js';
 async function tmpDir() {
     return fs.mkdtemp(path.join(os.tmpdir(), 'runtime-overrides-'));
 }
 describe('resolveOverridesPath', () => {
     it('uses configured data dir when provided', () => {
-        const out = resolveOverridesPath('/var/lib/discoclaw', '/repo');
-        expect(out).toBe(path.join('/var/lib/discoclaw', 'runtime-overrides.json'));
-    });
-    it('falls back to <projectRoot>/data when data dir is empty string', () => {
-        const out = resolveOverridesPath('', '/repo');
-        expect(out).toBe(path.join('/repo', 'data', 'runtime-overrides.json'));
+        expect(resolveOverridesPath('/var/lib/discoclaw', '/repo')).toBe('/var/lib/discoclaw/runtime-overrides.json');
     });
-    it('falls back to <projectRoot>/data when data dir is undefined', () => {
-        const out = resolveOverridesPath(undefined, '/repo');
-        expect(out).toBe(path.join('/repo', 'data', 'runtime-overrides.json'));
+    it('falls back to <projectRoot>/data when data dir is absent', () => {
+        expect(resolveOverridesPath(undefined, '/repo')).toBe('/repo/data/runtime-overrides.json');
     });
 });
-describe('loadOverrides', () => {
+describe('loadOverrides and saveOverrides', () => {
     const dirs = [];
     afterEach(async () => {
-        for (const d of dirs) {
-            await fs.rm(d, { recursive: true, force: true });
+        for (const dir of dirs) {
+            await fs.rm(dir, { recursive: true, force: true });
         }
         dirs.length = 0;
     });
-    it('returns empty object when file does not exist', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const result = await loadOverrides(path.join(dir, 'runtime-overrides.json'));
-        expect(result).toEqual({});
-    });
-    it('loads ttsVoice from a valid file', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ ttsVoice: 'aura-2-luna-en' }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({ ttsVoice: 'aura-2-luna-en' });
-    });
-    it('returns empty object for corrupt JSON and calls onWarn', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, 'not-valid-json', 'utf-8');
-        const warnings = [];
-        const result = await loadOverrides(filePath, (msg) => warnings.push(msg));
-        expect(result).toEqual({});
-        expect(warnings).toHaveLength(1);
-        expect(warnings[0]).toMatch(/corrupt JSON/);
-    });
-    it('returns empty object when JSON root is an array and calls onWarn', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify(['opus']), 'utf-8');
-        const warnings = [];
-        const result = await loadOverrides(filePath, (msg) => warnings.push(msg));
-        expect(result).toEqual({});
-        expect(warnings).toHaveLength(1);
-        expect(warnings[0]).toMatch(/not an object/);
-    });
-    it('returns empty object when JSON root is a primitive and calls onWarn', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify(42), 'utf-8');
-        const warnings = [];
-        const result = await loadOverrides(filePath, (msg) => warnings.push(msg));
-        expect(result).toEqual({});
-        expect(warnings).toHaveLength(1);
-        expect(warnings[0]).toMatch(/not an object/);
-    });
-    it('silently drops unknown top-level fields (including legacy models key)', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ models: { chat: 'sonnet' }, unknownField: 'x' }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({});
-    });
-    it('loads ttsVoice field correctly', async () => {
+    it('returns empty object when the file does not exist', async () => {
         const dir = await tmpDir();
         dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ ttsVoice: 'aura-2-asteria-en' }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({ ttsVoice: 'aura-2-asteria-en' });
+        await expect(loadOverrides(path.join(dir, 'runtime-overrides.json'))).resolves.toEqual({});
     });
-    it('silently drops ttsVoice when it is not a string', async () => {
+    it('round-trips managed runtime overrides', async () => {
         const dir = await tmpDir();
         dirs.push(dir);
         const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ ttsVoice: 42 }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({});
-    });
-    it('loads voiceRuntime field correctly', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ voiceRuntime: 'gemini-api' }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({ voiceRuntime: 'gemini-api' });
+        await saveOverrides(filePath, { voiceRuntime: 'claude-api', fastRuntime: 'codex-cli' });
+        await expect(loadOverrides(filePath)).resolves.toEqual({
+            voiceRuntime: 'claude-api',
+            fastRuntime: 'codex-cli',
+        });
     });
-    it('silently drops voiceRuntime when it is not a string', async () => {
+    it('drops legacy ttsVoice while preserving unrelated keys', async () => {
         const dir = await tmpDir();
         dirs.push(dir);
         const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ voiceRuntime: 123 }), 'utf-8');
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({});
+        await fs.writeFile(filePath, JSON.stringify({ customFlag: true, ttsVoice: 'old-voice', voiceRuntime: 'gemini-api' }), 'utf-8');
+        await saveOverrides(filePath, { fastRuntime: 'codex-cli' });
+        const raw = JSON.parse(await fs.readFile(filePath, 'utf-8'));
+        expect(raw).toEqual({ customFlag: true, fastRuntime: 'codex-cli' });
     });
 });
 describe('normalizeRuntimeOverrides', () => {
-    it('canonicalizes accepted voice runtime aliases', () => {
-        const result = normalizeRuntimeOverrides({ voiceRuntime: 'Anthropic' });
-        expect(result).toEqual({
-            overrides: { voiceRuntime: 'claude-api' },
+    it('canonicalizes accepted runtime aliases', () => {
+        expect(normalizeRuntimeOverrides({ voiceRuntime: 'Anthropic', fastRuntime: 'claude_code' })).toEqual({
+            overrides: { voiceRuntime: 'claude-api', fastRuntime: 'claude-cli' },
             changed: true,
         });
     });
-    it('canonicalizes accepted fast runtime aliases', () => {
-        const result = normalizeRuntimeOverrides({ fastRuntime: 'claude_code' });
-        expect(result).toEqual({
-            overrides: { fastRuntime: 'claude-cli' },
-            changed: true,
-        });
-    });
-    it('leaves invalid or already-canonical runtime values unchanged', () => {
-        const result = normalizeRuntimeOverrides({
-            voiceRuntime: 'claude-api',
-            fastRuntime: 'not-a-runtime',
-            ttsVoice: 'aura-2-asteria-en',
-        });
-        expect(result).toEqual({
-            overrides: {
-                voiceRuntime: 'claude-api',
-                fastRuntime: 'not-a-runtime',
-                ttsVoice: 'aura-2-asteria-en',
-            },
+    it('leaves invalid or canonical runtime values unchanged', () => {
+        expect(normalizeRuntimeOverrides({ voiceRuntime: 'claude-api', fastRuntime: 'not-a-runtime' })).toEqual({
+            overrides: { voiceRuntime: 'claude-api', fastRuntime: 'not-a-runtime' },
             changed: false,
         });
     });
 });
-describe('saveOverrides', () => {
-    const dirs = [];
-    afterEach(async () => {
-        for (const d of dirs) {
-            await fs.rm(d, { recursive: true, force: true });
-        }
-        dirs.length = 0;
-    });
-    it('writes overrides and reads them back correctly', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await saveOverrides(filePath, { ttsVoice: 'aura-2-asteria-en', voiceRuntime: 'claude-api' });
-        const raw = await fs.readFile(filePath, 'utf-8');
-        expect(JSON.parse(raw)).toEqual({ ttsVoice: 'aura-2-asteria-en', voiceRuntime: 'claude-api' });
-    });
-    it('writes ttsVoice and reads it back correctly', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await saveOverrides(filePath, { ttsVoice: 'aura-2-asteria-en' });
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual({ ttsVoice: 'aura-2-asteria-en' });
-    });
-    it('round-trips ttsVoice + voiceRuntime through save and load', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        const original = {
-            ttsVoice: 'aura-2-luna-en',
-            voiceRuntime: 'gemini-api',
-        };
-        await saveOverrides(filePath, original);
-        const result = await loadOverrides(filePath);
-        expect(result).toEqual(original);
-    });
-    it('creates the parent directory when it does not exist', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'subdir', 'runtime-overrides.json');
-        await saveOverrides(filePath, { voiceRuntime: 'claude-api' });
-        const raw = await fs.readFile(filePath, 'utf-8');
-        expect(JSON.parse(raw)).toEqual({ voiceRuntime: 'claude-api' });
-    });
-    it('leaves no tmp file behind after a successful write', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await saveOverrides(filePath, { ttsVoice: 'aura-2-asteria-en' });
-        const files = await fs.readdir(dir);
-        const tmpFiles = files.filter((f) => f.includes('.tmp.'));
-        expect(tmpFiles).toHaveLength(0);
-    });
-    it('overwrites an existing overrides file', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await saveOverrides(filePath, { ttsVoice: 'voice-a' });
-        await saveOverrides(filePath, { ttsVoice: 'voice-b' });
-        const raw = await fs.readFile(filePath, 'utf-8');
-        expect(JSON.parse(raw)).toEqual({ ttsVoice: 'voice-b' });
-    });
-    it('preserves unknown keys while replacing known runtime override fields', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await fs.writeFile(filePath, JSON.stringify({ customFlag: true, voiceRuntime: 'claude-api', ttsVoice: 'voice-a' }), 'utf-8');
-        await saveOverrides(filePath, { fastRuntime: 'openrouter' });
-        const raw = await fs.readFile(filePath, 'utf-8');
-        expect(JSON.parse(raw)).toEqual({ customFlag: true, fastRuntime: 'openrouter' });
-    });
-    it('writes an empty overrides object', async () => {
-        const dir = await tmpDir();
-        dirs.push(dir);
-        const filePath = path.join(dir, 'runtime-overrides.json');
-        await saveOverrides(filePath, {});
-        const raw = await fs.readFile(filePath, 'utf-8');
-        expect(JSON.parse(raw)).toEqual({});
-    });
-});

package/dist/tasks/store.js

@@ -227,14 +227,18 @@ export class TaskStore extends EventEmitter {
         if (!prev)
             throw new Error(`task not found: ${id}`);
         const now = new Date().toISOString();
+        const updateParams = params;
         const updated = {
             ...prev,
-            ...(params.title !== undefined && { title: params.title }),
-            ...(params.description !== undefined && { description: params.description }),
-            ...(params.priority !== undefined && { priority: params.priority }),
-            ...(params.status !== undefined && { status: params.status }),
-            ...(params.owner !== undefined && { owner: params.owner }),
-            ...(params.externalRef !== undefined && { external_ref: params.externalRef }),
+            ...(updateParams.title !== undefined && { title: updateParams.title }),
+            ...(updateParams.description !== undefined && { description: updateParams.description }),
+            ...(updateParams.priority !== undefined && { priority: updateParams.priority }),
+            ...(updateParams.status !== undefined && { status: updateParams.status }),
+            ...(updateParams.owner !== undefined && { owner: updateParams.owner }),
+            ...(updateParams.externalRef !== undefined && { external_ref: updateParams.externalRef }),
+            ...(updateParams.threadOriginGuild !== undefined && {
+                thread_origin_guild: updateParams.threadOriginGuild,
+            }),
             updated_at: now,
         };
         this.tasks.set(id, updated);

package/dist/tasks/store.test.js

@@ -408,6 +408,50 @@ describe('TaskStore — persistence', () => {
         expect(loaded.close_reason).toBe('done');
         await fsp.default.unlink(path).catch(() => { });
     });
+    it('persists thread origin guild when update provides it', async () => {
+        const fsp = await import('node:fs/promises');
+        const path = '/tmp/discoclaw-test-store-thread-origin-guild.jsonl';
+        await fsp.default.unlink(path).catch(() => { });
+        const store1 = new TaskStore({ prefix: 'ws', persistPath: path });
+        const task = store1.create({ title: 'T' });
+        store1.update(task.id, {
+            externalRef: 'discord:123',
+            threadOriginGuild: 'guild-456',
+        });
+        await store1.flush();
+        const persisted = JSON.parse((await fsp.default.readFile(path, 'utf8')).trim());
+        expect(persisted.external_ref).toBe('discord:123');
+        expect(persisted.thread_origin_guild).toBe('guild-456');
+        const store2 = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store2.load();
+        const loaded = store2.get(task.id);
+        expect(loaded?.thread_origin_guild).toBe('guild-456');
+        await fsp.default.unlink(path).catch(() => { });
+    });
+    it('keeps legacy tasks without thread origin guild readable and writable', async () => {
+        const fsp = await import('node:fs/promises');
+        const path = '/tmp/discoclaw-test-store-legacy-thread-origin-guild.jsonl';
+        await fsp.default.unlink(path).catch(() => { });
+        const legacyTask = {
+            id: 'ws-001',
+            title: 'Legacy task',
+            status: 'open',
+            external_ref: 'discord:123',
+            created_at: '2026-04-06T00:00:00.000Z',
+            updated_at: '2026-04-06T00:00:00.000Z',
+        };
+        await fsp.default.writeFile(path, `${JSON.stringify(legacyTask)}\n`, 'utf8');
+        const store = new TaskStore({ prefix: 'ws', persistPath: path });
+        await store.load();
+        const loaded = store.get('ws-001');
+        expect(loaded?.thread_origin_guild).toBeUndefined();
+        store.update('ws-001', { title: 'Legacy task updated' });
+        await store.flush();
+        const rewritten = JSON.parse((await fsp.default.readFile(path, 'utf8')).trim());
+        expect(rewritten.title).toBe('Legacy task updated');
+        expect(rewritten.thread_origin_guild).toBeUndefined();
+        await fsp.default.unlink(path).catch(() => { });
+    });
     it('is a no-op when no persistPath is configured', async () => {
         const store = new TaskStore({ prefix: 'ws' });
         store.create({ title: 'T' });