discoclaw 1.2.4 → 2.0.0

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' });

package/dist/tasks/task-action-executor.test.js

@@ -50,11 +50,11 @@ vi.mock('./task-sync-engine.js', () => {
 // ---------------------------------------------------------------------------
 function makeCtx() {
     return {
-        guild: {},
+        guild: { id: 'guild-current' },
         client: {
             channels: {
                 cache: {
-                    get: () => undefined,
+                    get: vi.fn(() => undefined),
                 },
             },
         },
@@ -62,8 +62,8 @@ function makeCtx() {
         messageId: 'msg-current',
     };
 }
-function makeStore() {
-    const defaultTask = (id) => ({
+function makeTask(id, overrides = {}) {
+    return {
         id,
         title: 'Test task',
         description: 'A test',
@@ -76,34 +76,81 @@ function makeStore() {
         comments: [],
         created_at: '2026-01-01T00:00:00Z',
         updated_at: '2026-01-01T00:00:00Z',
-    });
+        ...overrides,
+    };
+}
+function makeStore(opts) {
+    const tasks = new Map((opts?.initialTasks ?? [
+        makeTask('ws-001', { title: 'First' }),
+        makeTask('ws-002', {
+            title: 'Second',
+            status: 'in_progress',
+            priority: 1,
+            external_ref: 'discord:222333444',
+            labels: [],
+        }),
+    ]).map((task) => [task.id, task]));
     return {
-        get: vi.fn((id) => {
-            if (id === 'ws-notfound')
-                return undefined;
-            return defaultTask(id);
+        get: vi.fn((id) => tasks.get(id)),
+        list: vi.fn((params) => (Array.from(tasks.values()).slice(0, params?.limit ?? 50))),
+        create: vi.fn((params) => {
+            const createTaskOverrides = typeof opts?.createTaskOverrides === 'function'
+                ? opts.createTaskOverrides(params)
+                : (opts?.createTaskOverrides ?? {});
+            const task = makeTask('ws-new', {
+                title: params.title,
+                description: params.description ?? '',
+                priority: params.priority ?? 2,
+                external_ref: '',
+                labels: params.labels ?? [],
+                ...createTaskOverrides,
+            });
+            tasks.set(task.id, task);
+            return task;
+        }),
+        update: vi.fn((id, params) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...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 } : {}),
+                ...(params.threadOriginGuild !== undefined ? { thread_origin_guild: params.threadOriginGuild } : {}),
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
+        }),
+        close: vi.fn((id) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...prev,
+                status: 'closed',
+                closed_at: '2026-01-02T00:00:00Z',
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
+        }),
+        addLabel: vi.fn((id, label) => {
+            const prev = tasks.get(id);
+            if (!prev)
+                throw new Error(`task not found: ${id}`);
+            const updated = makeTask(id, {
+                ...prev,
+                labels: [...new Set([...(prev.labels ?? []), label])],
+                updated_at: '2026-01-02T00:00:00Z',
+            });
+            tasks.set(id, updated);
+            return updated;
         }),
-        list: vi.fn(() => [
-            { id: 'ws-001', title: 'First', status: 'open', priority: 2 },
-            { id: 'ws-002', title: 'Second', status: 'in_progress', priority: 1 },
-        ]),
-        create: vi.fn((params) => ({
-            id: 'ws-new',
-            title: params.title,
-            description: params.description ?? '',
-            status: 'open',
-            priority: params.priority ?? 2,
-            issue_type: 'task',
-            owner: '',
-            external_ref: '',
-            labels: params.labels ?? [],
-            comments: [],
-            created_at: '2026-01-01T00:00:00Z',
-            updated_at: '2026-01-01T00:00:00Z',
-        })),
-        update: vi.fn((id) => defaultTask(id)),
-        close: vi.fn((id) => ({ ...defaultTask(id), status: 'closed' })),
-        addLabel: vi.fn((id) => defaultTask(id)),
         reload: vi.fn(async () => ({ added: [], updated: [], removed: [] })),
     };
 }
@@ -137,11 +184,19 @@ describe('TASK_ACTION_TYPES', () => {
     });
 });
 describe('executeTaskAction', () => {
-    it('taskCreate returns created task summary', async () => {
+    it('taskCreate returns a real Discord thread URL and structured thread metadata', async () => {
         const result = await executeTaskAction({ type: 'taskCreate', title: 'New task', priority: 1 }, makeCtx(), makeTaskCtx());
+        const success = result;
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('ws-new');
-        expect(result.summary).toContain('New task');
+        expect(success.summary).toContain('ws-new');
+        expect(success.summary).toContain('New task');
+        expect(success.summary).toContain('Thread: https://discord.com/channels/guild-current/thread-new');
+        expect(success.thread).toEqual({
+            externalRef: 'discord:thread-new',
+            threadId: 'thread-new',
+            threadGuildId: 'guild-current',
+            threadUrl: 'https://discord.com/channels/guild-current/thread-new',
+        });
     });
     it('taskCreate calls forumCountSync.requestUpdate', async () => {
         const mockSync = { requestUpdate: vi.fn(), stop: vi.fn() };
@@ -157,28 +212,29 @@ describe('executeTaskAction', () => {
         createTaskThread.mockClear?.();
         const result = await executeTaskAction({ type: 'taskCreate', title: 'No thread please', tags: 'no-thread,feature' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(true);
+        expect(result.summary).not.toContain('Thread:');
+        expect(result.thread).toBeUndefined();
         expect(createTaskThread).not.toHaveBeenCalled();
     });
-    it('taskCreate skips thread creation when task is already linked before direct lifecycle step', async () => {
+    it('taskCreate backfills missing origin guild data for already-linked tasks', async () => {
         const { createTaskThread } = await import('./thread-ops.js');
         createTaskThread.mockClear?.();
-        const store = makeStore();
-        store.get.mockImplementation((id) => ({
-            id,
-            title: 'Already linked',
-            status: 'open',
-            priority: 2,
-            issue_type: 'task',
-            owner: '',
-            external_ref: 'discord:thread-existing',
-            labels: ['feature'],
-            comments: [],
-            created_at: '2026-01-01T00:00:00Z',
-            updated_at: '2026-01-01T00:00:00Z',
-        }));
+        const store = makeStore({
+            createTaskOverrides: {
+                title: 'Already linked',
+                external_ref: 'discord:thread-existing',
+            },
+        });
         const result = await executeTaskAction({ type: 'taskCreate', title: 'Task already linked' }, makeCtx(), makeTaskCtx({ store: store }));
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('thread linked');
+        expect(result.summary).toContain('Thread: https://discord.com/channels/guild-current/thread-existing');
+        expect(result.thread).toEqual({
+            externalRef: 'discord:thread-existing',
+            threadId: 'thread-existing',
+            threadGuildId: 'guild-current',
+            threadUrl: 'https://discord.com/channels/guild-current/thread-existing',
+        });
+        expect(store.update).toHaveBeenCalledWith('ws-new', { threadOriginGuild: 'guild-current' });
         expect(createTaskThread).not.toHaveBeenCalled();
     });
     it('taskUpdate returns updated summary', async () => {
@@ -301,9 +357,65 @@ describe('executeTaskAction', () => {
     it('taskShow returns task details', async () => {
         const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(true);
-        expect(result.summary).toContain('Test task');
+        expect(result.summary).toContain('First');
         expect(result.summary).toContain('ws-001');
     });
+    it('taskShow shows External ref for linked tasks even without canonical thread URL data', async () => {
+        const store = makeStore({
+            initialTasks: [
+                makeTask('ws-001', {
+                    title: 'Linked elsewhere',
+                    external_ref: 'gh:123',
+                    thread_origin_guild: undefined,
+                }),
+            ],
+        });
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('External ref: gh:123');
+        expect(result.summary).not.toContain('Thread:');
+        expect(result.thread).toEqual({ externalRef: 'gh:123' });
+    });
+    it('taskShow only emits Thread when stored origin guild data exists', async () => {
+        const store = makeStore({
+            initialTasks: [
+                makeTask('ws-001', {
+                    title: 'Thread-linked',
+                    external_ref: 'discord:111222333',
+                    thread_origin_guild: 'guild-stored',
+                }),
+            ],
+        });
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, makeCtx(), makeTaskCtx({ store: store }));
+        expect(result.ok).toBe(true);
+        expect(result.summary).toContain('External ref: discord:111222333');
+        expect(result.summary).toContain('Thread: https://discord.com/channels/guild-stored/111222333');
+        expect(result.thread).toEqual({
+            externalRef: 'discord:111222333',
+            threadId: '111222333',
+            threadGuildId: 'guild-stored',
+            threadUrl: 'https://discord.com/channels/guild-stored/111222333',
+        });
+    });
+    it('taskShow does not perform live Discord lookups', async () => {
+        const { resolveTasksForum } = await import('./thread-ops.js');
+        resolveTasksForum.mockClear?.();
+        const ctx = makeCtx();
+        const cacheGet = ctx.client.channels.cache.get;
+        const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-001' }, ctx, makeTaskCtx({
+            store: makeStore({
+                initialTasks: [
+                    makeTask('ws-001', {
+                        external_ref: 'discord:111222333',
+                        thread_origin_guild: 'guild-stored',
+                    }),
+                ],
+            }),
+        }));
+        expect(result.ok).toBe(true);
+        expect(resolveTasksForum).not.toHaveBeenCalled();
+        expect(cacheGet).not.toHaveBeenCalled();
+    });
     it('taskShow fails for unknown task', async () => {
         const result = await executeTaskAction({ type: 'taskShow', taskId: 'ws-notfound' }, makeCtx(), makeTaskCtx());
         expect(result.ok).toBe(false);

package/dist/tasks/task-action-mutations.js

@@ -4,6 +4,7 @@ import { autoTagTask } from './auto-tag.js';
 import { taskThreadCache } from './thread-cache.js';
 import { resolveTaskId, resolveTaskService, scheduleRepairSync, } from './task-action-mutation-helpers.js';
 import { ensureCreatedTaskThreadLink, syncClosedTaskThread, syncUpdatedTaskThread, } from './task-action-thread-sync.js';
+import { getTaskActionThreadMetadata } from './task-action-runner-types.js';
 /** Pre-computed set for filtering status names from tag candidates. */
 const STATUS_NAME_SET = new Set(TASK_STATUSES);
 /**
@@ -73,10 +74,29 @@ export async function handleTaskCreate(action, ctx, taskCtx) {
     if (needsRepairSync) {
         scheduleRepairSync(taskCtx, task.id, ctx);
     }
+    let linkedTask = taskCtx.store.get(task.id) ?? task;
+    const storedThread = getTaskActionThreadMetadata(linkedTask);
+    const linkedThreadId = storedThread?.threadId ?? (threadId || undefined);
+    const guildId = ctx.guild.id?.trim() || undefined;
+    if (linkedThreadId && guildId && !linkedTask.thread_origin_guild) {
+        try {
+            linkedTask = taskService.update(task.id, {
+                ...(storedThread ? {} : { externalRef: `discord:${linkedThreadId}` }),
+                threadOriginGuild: guildId,
+            });
+        }
+        catch (err) {
+            taskCtx.log?.warn({ err, taskId: task.id, threadId: linkedThreadId, guildId }, 'tasks:thread origin guild update failed');
+        }
+    }
+    const thread = getTaskActionThreadMetadata(linkedTask);
     taskThreadCache.invalidate();
     taskCtx.forumCountSync?.requestUpdate();
-    const threadNote = threadId ? ' (thread linked)' : '';
-    return { ok: true, summary: `Task ${task.id} created: "${task.title}"${threadNote}` };
+    const summary = [
+        `Task ${task.id} created: "${task.title}"`,
+        ...(thread?.threadUrl ? [`Thread: ${thread.threadUrl}`] : []),
+    ].join('\n');
+    return { ok: true, summary, ...(thread ? { thread } : {}) };
 }
 export async function handleTaskUpdate(action, ctx, taskCtx) {
     const taskId = resolveTaskId(action);