@taskforcehq/taskforce 0.3.169 → 0.3.300

package/dist/core/AiProfiles.test.js

@@ -0,0 +1,449 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { afterEach, describe, expect, it } from 'vitest';
+import { TaskforceCore } from './Taskforce';
+function createProjectRoot(prefix = 'taskforce-ai-profiles-') {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'ai-profiles-test' }), 'utf-8');
+    return root;
+}
+const createdRoots = [];
+afterEach(() => {
+    while (createdRoots.length > 0) {
+        const root = createdRoots.pop();
+        if (root && fs.existsSync(root)) {
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    }
+});
+describe('TaskforceCore ai profiles', () => {
+    it('creates workspace-scoped ai profiles and resolves them into task actor surfaces', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            icon: 'Bot',
+            color: '#ef6c00'
+        });
+        expect(resolved.created).toBe(true);
+        const actors = core.listAssignableActors('workspace-1');
+        expect(actors.some((actor) => actor.id === resolved.profile.id && actor.label === 'Codex' && actor.kind === 'ai')).toBe(true);
+        const task = core.createTask({
+            title: 'Assigned to named AI',
+            assignee: resolved.profile.id,
+            createdBy: resolved.profile.id,
+            comments: [
+                {
+                    id: 'comment-1',
+                    author: resolved.profile.id,
+                    text: 'Hello from Codex',
+                    timestamp: '2026-03-22T10:00:00.000Z'
+                }
+            ]
+        }, { workspaceId: 'workspace-1' });
+        const fetched = core.getTask(task.id, 'workspace-1');
+        expect(fetched?.assignee).toBe(resolved.profile.id);
+        expect(fetched?.assigneeActor?.label).toBe('Codex');
+        expect(fetched?.createdByActor?.label).toBe('Codex');
+        expect(fetched?.comments?.[0]?.actor?.label).toBe('Codex');
+    });
+    it('updates existing ai profile presentation fields when profileToken is presented again', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Claude',
+            color: '#f59e0b'
+        });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Claude 2',
+            icon: 'Sparkles',
+            color: '#0ea5e9',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.created).toBe(false);
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(second.profile.name).toBe('Claude 2');
+        expect(second.profile.username).toBe('claude-2');
+        expect(second.profile.icon).toBe('Sparkles');
+        expect(second.profile.color).toBe('#0ea5e9');
+    });
+    it('stores expanded ai profile fields and preserves them when omitted on re-resolve', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            description: 'Builds and repairs product code',
+            role: 'Implementer',
+            provider: 'OpenAI',
+            model: 'gpt-5.4',
+            surfaceType: 'coding_tool'
+        });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            color: '#0ea5e9',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.profile.description).toBe('Builds and repairs product code');
+        expect(second.profile.role).toBe('Implementer');
+        expect(second.profile.provider).toBe('OpenAI');
+        expect(second.profile.model).toBe('gpt-5.4');
+        expect(second.profile.surfaceType).toBe('coding_tool');
+        expect(second.profile.color).toBe('#0ea5e9');
+    });
+    it('ignores empty-string optional ai profile updates instead of clearing stored values', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Reviewer',
+            description: 'Reviews implementation plans',
+            role: 'Reviewer',
+            provider: 'Anthropic',
+            model: 'claude-sonnet'
+        });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Reviewer',
+            description: '   ',
+            role: '',
+            provider: ' ',
+            model: '',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.profile.description).toBe('Reviews implementation plans');
+        expect(second.profile.role).toBe('Reviewer');
+        expect(second.profile.provider).toBe('Anthropic');
+        expect(second.profile.model).toBe('claude-sonnet');
+    });
+    it('clears ai profile surfaceType when re-resolved with null or an empty string', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'ChatGPT',
+            surfaceType: 'chat_app'
+        });
+        const clearedWithNull = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'ChatGPT',
+            surfaceType: null,
+            profileToken: first.profile.profileToken
+        });
+        expect(clearedWithNull.profile.surfaceType).toBeNull();
+        const reset = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'ChatGPT',
+            surfaceType: 'chat_app',
+            profileToken: first.profile.profileToken
+        });
+        expect(reset.profile.surfaceType).toBe('chat_app');
+        const clearedWithEmptyString = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'ChatGPT',
+            surfaceType: '',
+            profileToken: first.profile.profileToken
+        });
+        expect(clearedWithEmptyString.profile.surfaceType).toBeNull();
+    });
+    it('preserves ai profile surfaceType when re-resolved without the field', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'coding_tool'
+        });
+        const second = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            profileToken: first.profile.profileToken
+        });
+        expect(second.profile.surfaceType).toBe('coding_tool');
+    });
+    it('rejects invalid ai profile surfaceType values', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        expect(() => core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Codex',
+            surfaceType: 'desktop_app'
+        })).toThrow(/surfaceType/i);
+    });
+    it('repairs legacy ai_profiles tables that are missing newer columns', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const storageDir = path.join(projectRoot, '.taskforce');
+        fs.mkdirSync(storageDir, { recursive: true });
+        const dbPath = path.join(storageDir, 'taskforce.db');
+        const db = new Database(dbPath);
+        db.exec(`
+            CREATE TABLE ai_profiles (
+                id TEXT PRIMARY KEY,
+                tenant_id TEXT NOT NULL DEFAULT 'default',
+                workspace_id TEXT NOT NULL DEFAULT 'default',
+                profile_token TEXT NOT NULL,
+                name TEXT NOT NULL,
+                username TEXT NOT NULL,
+                icon TEXT NOT NULL,
+                color TEXT NOT NULL,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL
+            );
+        `);
+        db.prepare(`
+            INSERT INTO ai_profiles (
+                id, tenant_id, workspace_id, profile_token, name, username, icon, color, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('ai-profile-legacy-codex', 'default', 'workspace-1', 'tfp_legacy_codex', 'Codex', 'codex', 'Bot', '#0ea5e9', '2026-03-22T10:00:00.000Z', '2026-03-22T10:05:00.000Z');
+        db.close();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const profiles = core.listAiProfiles('workspace-1');
+        expect(profiles).toEqual([
+            expect.objectContaining({
+                id: 'ai-profile-legacy-codex',
+                name: 'Codex',
+                username: 'codex',
+                description: null,
+                role: null,
+                provider: null,
+                model: null,
+                surfaceType: null,
+                lastActiveAt: null
+            })
+        ]);
+    });
+    it('orders ai profiles case-insensitively without sqlite-specific collation syntax', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const sameTimestamp = '2026-03-22T12:00:00.000Z';
+        const db = core.db;
+        db.prepare(`
+            INSERT INTO ai_profiles (
+                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
+                provider_metadata_json, created_at, updated_at, last_active_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('ai-profile-zebra', 'default', 'workspace-1', 'tfp_zebra', 'zebra', 'zebra', 'Bot', '#111111', null, sameTimestamp, sameTimestamp, null);
+        db.prepare(`
+            INSERT INTO ai_profiles (
+                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
+                provider_metadata_json, created_at, updated_at, last_active_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('ai-profile-alpha', 'default', 'workspace-1', 'tfp_alpha', 'Alpha', 'alpha', 'Bot', '#222222', null, sameTimestamp, sameTimestamp, null);
+        db.prepare(`
+            INSERT INTO ai_profiles (
+                id, tenant_id, workspace_id, profile_token, name, username, icon, color,
+                provider_metadata_json, created_at, updated_at, last_active_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('ai-profile-bravo', 'default', 'workspace-1', 'tfp_bravo', 'bravo', 'bravo', 'Bot', '#333333', null, sameTimestamp, sameTimestamp, null);
+        expect(core.listAiProfiles('workspace-1').map((profile) => profile.name)).toEqual([
+            'Alpha',
+            'bravo',
+            'zebra'
+        ]);
+    });
+    it('uses a postgres-safe ordering expression for ai profiles', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        let capturedSql = '';
+        core.db = {
+            provider: 'postgres',
+            prepare(sql) {
+                capturedSql = sql;
+                return {
+                    all() {
+                        return [];
+                    }
+                };
+            }
+        };
+        expect(core.listAiProfiles('workspace-1')).toEqual([]);
+        expect(capturedSql).toContain('LOWER(name) ASC');
+        expect(capturedSql).not.toContain('COLLATE NOCASE');
+    });
+    it('resolves actor by display name when comment author is a name rather than profile ID', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const { profile } = core.resolveAiProfile({
+            workspaceId: 'workspace-1',
+            name: 'Claude',
+            color: '#f59e0b'
+        });
+        // Resolve by name (e.g. agent passed "Claude" as author instead of profile ID)
+        const actorByName = core.resolveWorkspaceActor('workspace-1', 'Claude');
+        expect(actorByName).not.toBeNull();
+        expect(actorByName?.id).toBe(profile.id);
+        expect(actorByName?.kind).toBe('ai');
+        expect(actorByName?.label).toBe('Claude');
+        // Case-insensitive
+        const actorLower = core.resolveWorkspaceActor('workspace-1', 'claude');
+        expect(actorLower?.id).toBe(profile.id);
+    });
+    it('classifies well-known AI model names as ai-kind even without a registered profile', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        // No profile registered, but name is a known AI model
+        const actor = core.resolveWorkspaceActor('workspace-1', 'chatgpt');
+        expect(actor?.kind).toBe('ai');
+        const actorCodex = core.resolveWorkspaceActor('workspace-1', 'codex');
+        expect(actorCodex?.kind).toBe('ai');
+        // Unknown string should default to human
+        const actorUnknown = core.resolveWorkspaceActor('workspace-1', 'randomstring123');
+        expect(actorUnknown?.kind).toBe('human');
+    });
+    it('reuses the existing profile when re-registering the same AI by exact name', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
+        expect(first.created).toBe(true);
+        expect(first.duplicateWarning).toBeUndefined();
+        // Second creation without a token should reuse instead of minting a duplicate.
+        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
+        expect(second.created).toBe(false);
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+    });
+    it('reuses Codex by exact name without leaking across workspaces', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        core.createWorkspace({ workspaceId: 'workspace-2', name: 'Workspace 2' });
+        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
+        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Codex' });
+        const otherWorkspace = core.resolveAiProfile({ workspaceId: 'workspace-2', name: 'Codex' });
+        expect(first.created).toBe(true);
+        expect(second.created).toBe(false);
+        expect(second.profile.id).toBe(first.profile.id);
+        expect(otherWorkspace.created).toBe(true);
+        expect(otherWorkspace.profile.id).not.toBe(first.profile.id);
+        expect(core.listAiProfiles('workspace-1')).toHaveLength(1);
+        expect(core.listAiProfiles('workspace-2')).toHaveLength(1);
+    });
+    it('merges two duplicate profiles, reassigning task assignees and comment authors', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const first = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
+        const second = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity Clone' });
+        // Create a task assigned to the duplicate and a comment authored by it
+        const task = core.createTask({
+            title: 'Task with duplicate assignee',
+            assignee: second.profile.id,
+            comments: [{
+                    id: 'c1',
+                    author: second.profile.id,
+                    text: 'Comment from duplicate',
+                    timestamp: '2026-03-22T10:00:00.000Z'
+                }]
+        }, { workspaceId: 'workspace-1' });
+        // Merge the duplicate into the original
+        const merged = core.mergeAiProfiles({
+            workspaceId: 'workspace-1',
+            keepId: first.profile.id,
+            mergeId: second.profile.id
+        });
+        expect(merged.id).toBe(first.profile.id);
+        // Duplicate profile should be gone
+        const profiles = core.listAiProfiles('workspace-1');
+        expect(profiles.some((p) => p.id === second.profile.id)).toBe(false);
+        expect(profiles.some((p) => p.id === first.profile.id)).toBe(true);
+        // Task assignee should point to the kept profile
+        const updatedTask = core.getTask(task.id, 'workspace-1');
+        expect(updatedTask?.assignee).toBe(first.profile.id);
+        // Comment author should point to the kept profile
+        expect(updatedTask?.comments?.[0]?.author).toBe(first.profile.id);
+    });
+    it('canonicalizes AI names to profile ids when creating tasks and comments', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        core.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const resolved = core.resolveAiProfile({ workspaceId: 'workspace-1', name: 'ChatGPT', color: '#10a37f' });
+        const task = core.createTask({
+            title: 'Canonicalize actor refs',
+            createdBy: 'chatgpt',
+            assignee: 'ChatGPT',
+            comments: [{
+                    id: 'c1',
+                    author: 'chatgpt',
+                    text: 'Stored as canonical profile id',
+                    timestamp: '2026-03-22T10:00:00.000Z'
+                }]
+        }, { workspaceId: 'workspace-1' });
+        const fetched = core.getTask(task.id, 'workspace-1');
+        expect(fetched?.createdBy).toBe(resolved.profile.id);
+        expect(fetched?.assignee).toBe(resolved.profile.id);
+        expect(fetched?.comments?.[0]?.author).toBe(resolved.profile.id);
+        expect(fetched?.comments?.[0]?.submittedAuthor).toBe('chatgpt');
+        expect(fetched?.assigneeActor?.label).toBe('ChatGPT');
+        expect(fetched?.comments?.[0]?.actor?.label).toBe('ChatGPT');
+    });
+    it('repairs legacy actor refs and merges duplicate ai profiles on startup', () => {
+        const projectRoot = createProjectRoot();
+        createdRoots.push(projectRoot);
+        const firstCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        firstCore.createWorkspace({ workspaceId: 'workspace-1', name: 'Workspace 1' });
+        const firstDb = firstCore.db;
+        const first = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity' });
+        const second = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Antigravity Clone' });
+        firstDb.prepare(`UPDATE ai_profiles SET name = 'Antigravity', username = 'antigravity' WHERE tenant_id = ? AND id = ?`)
+            .run('default', second.profile.id);
+        firstDb.prepare(`DELETE FROM system_settings WHERE tenant_id = ? AND settings_key IN (?, ?)`)
+            .run('default', 'migration.ai_profiles.dedupe.v1', 'migration.actor_refs.canonicalize.v1');
+        const task = firstCore.createTask({
+            title: 'Legacy actor refs',
+            createdBy: 'claude',
+            assignee: 'antigravity',
+            comments: [
+                {
+                    id: 'legacy-comment',
+                    author: 'claude',
+                    text: 'Legacy claude alias',
+                    timestamp: '2026-03-22T10:00:00.000Z'
+                }
+            ]
+        }, { workspaceId: 'workspace-1' });
+        const claude = firstCore.resolveAiProfile({ workspaceId: 'workspace-1', name: 'Claude' });
+        expect(task.comments?.[0]?.author).toBe('claude');
+        const reloadedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const reloaded = reloadedCore.getTask(task.id, 'workspace-1');
+        const profiles = reloadedCore.listAiProfiles('workspace-1');
+        expect(profiles.map((profile) => profile.name)).toEqual(['Claude', 'Antigravity']);
+        const survivingAntigravityId = profiles.find((profile) => profile.name === 'Antigravity')?.id;
+        expect(reloaded?.createdBy).toBe(claude.profile.id);
+        expect(reloaded?.assignee).toBe(survivingAntigravityId);
+        expect(reloaded?.comments?.[0]?.author).toBe(claude.profile.id);
+        expect(reloaded?.comments?.[0]?.actor?.label).toBe('Claude');
+    });
+});

package/dist/core/AttachmentLinkService.d.ts

@@ -0,0 +1,15 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+export type AttachmentLinkInput = string | {
+    path: string;
+    fsPath?: string;
+    caption?: string;
+    displayName?: string;
+    originalFilename?: string;
+    timestamp?: string;
+};
+export interface AttachmentLinkServiceDeps {
+    db: DatabaseAdapter;
+    tenantId: string;
+    normalizeWorkspaceId: (workspaceId: string) => string;
+}
+export declare function syncCanonicalTaskAttachmentLinksService(deps: AttachmentLinkServiceDeps, taskId: string, workspaceId: string, attachments: AttachmentLinkInput[]): void;

package/dist/core/AttachmentLinkService.js

@@ -0,0 +1,157 @@
+import { createHash } from 'crypto';
+import * as path from 'path';
+function buildAttachmentDisplayName(attachment, fallbackNameRaw) {
+    const caption = typeof attachment === 'string' ? '' : String(attachment.caption || '').trim();
+    if (caption)
+        return caption;
+    const displayName = typeof attachment === 'string' ? '' : String(attachment.displayName || '').trim();
+    if (displayName)
+        return displayName;
+    const originalFilename = typeof attachment === 'string' ? '' : String(attachment.originalFilename || '').trim();
+    if (originalFilename)
+        return originalFilename;
+    const fallbackName = String(fallbackNameRaw || '').trim();
+    if (fallbackName)
+        return fallbackName;
+    const pathValue = typeof attachment === 'string'
+        ? attachment
+        : String(attachment.fsPath || attachment.path || '').trim();
+    const withoutQuery = pathValue.split('?')[0].split('#')[0];
+    return withoutQuery.split(/[\\/]/).pop() || 'Context file';
+}
+function normalizeAttachmentStorageKey(pathValue, fsPathValue) {
+    const fsPathRaw = String(fsPathValue || '').trim().replace(/\\/g, '/');
+    if (fsPathRaw) {
+        return fsPathRaw.replace(/^\.taskforce\//, '').trim() || null;
+    }
+    const routePathRaw = String(pathValue || '').trim();
+    if (/^https?:\/\//i.test(routePathRaw)) {
+        return routePathRaw;
+    }
+    if (routePathRaw.startsWith('/api/taskforce/context/')) {
+        return decodeURIComponent(routePathRaw.slice('/api/taskforce/context/'.length));
+    }
+    if (routePathRaw.startsWith('/api/taskforce/context-link?path=')) {
+        try {
+            const parsed = new URL(routePathRaw, 'http://localhost');
+            const linkedPath = String(parsed.searchParams.get('path') || '').trim();
+            return linkedPath ? linkedPath.replace(/\\/g, '/') : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function ensureExternalReferenceAsset(deps, storageKeyRaw, workspaceId, attachment) {
+    const storageKey = String(storageKeyRaw || '').trim();
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const timestamp = typeof attachment === 'string'
+        ? new Date().toISOString()
+        : String(attachment.timestamp || '').trim() || new Date().toISOString();
+    const urlHash = createHash('sha256').update(storageKey).digest('hex');
+    const assetId = `asset-${urlHash.slice(0, 32)}`;
+    let fallbackName = 'External Link';
+    let mimeType = 'text/uri-list';
+    try {
+        const parsed = new URL(storageKey);
+        const lastSegment = parsed.pathname.split('/').filter(Boolean).pop() || '';
+        fallbackName = lastSegment || parsed.hostname || fallbackName;
+    }
+    catch {
+        const normalizedPath = storageKey.replace(/\\/g, '/');
+        const lastSegment = normalizedPath.split('/').filter(Boolean).pop() || '';
+        fallbackName = lastSegment || fallbackName;
+        mimeType = 'application/octet-stream';
+    }
+    const logicalName = buildAttachmentDisplayName(attachment, fallbackName);
+    deps.db.prepare(`
+        INSERT INTO workspace_assets (
+            asset_id,
+            tenant_id,
+            workspace_id,
+            kind,
+            logical_name,
+            original_filename,
+            mime_type,
+            storage_provider,
+            storage_key,
+            content_sha256,
+            size_bytes,
+            document_id,
+            version,
+            is_latest,
+            scan_status,
+            scan_engine,
+            scan_details,
+            created_by_user_id,
+            created_at,
+            updated_at,
+            deleted_at,
+            purge_after
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL)
+        ON CONFLICT(asset_id) DO UPDATE SET
+            logical_name = excluded.logical_name,
+            original_filename = excluded.original_filename,
+            mime_type = excluded.mime_type,
+            storage_provider = excluded.storage_provider,
+            storage_key = excluded.storage_key,
+            content_sha256 = excluded.content_sha256,
+            size_bytes = excluded.size_bytes,
+            updated_at = excluded.updated_at,
+            deleted_at = NULL,
+            purge_after = NULL
+    `).run(assetId, deps.tenantId, normalizedWorkspaceId, 'file', logicalName, logicalName, mimeType, 'external', storageKey, urlHash, Buffer.byteLength(storageKey, 'utf8'), null, null, 1, 'clean', null, null, null, timestamp, timestamp);
+    return assetId;
+}
+export function syncCanonicalTaskAttachmentLinksService(deps, taskId, workspaceId, attachments) {
+    const normalizedTaskId = String(taskId || '').trim();
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    if (!normalizedTaskId)
+        return;
+    deps.db.prepare(`
+        UPDATE workspace_asset_links
+        SET deleted_at = ?, updated_at = ?
+        WHERE tenant_id = ? AND workspace_id = ? AND task_id = ? AND deleted_at IS NULL
+    `).run(new Date().toISOString(), new Date().toISOString(), deps.tenantId, normalizedWorkspaceId, normalizedTaskId);
+    const selectAsset = deps.db.prepare(`
+        SELECT asset_id, kind
+        FROM workspace_assets
+        WHERE tenant_id = ? AND workspace_id = ? AND storage_key = ? AND deleted_at IS NULL
+        LIMIT 1
+    `);
+    const upsertLink = deps.db.prepare(`
+        INSERT INTO workspace_asset_links (
+            tenant_id, workspace_id, asset_id, task_id, role, display_name, sort_order, created_at, updated_at, deleted_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+        ON CONFLICT (tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
+            display_name = excluded.display_name,
+            sort_order = excluded.sort_order,
+            updated_at = excluded.updated_at,
+            deleted_at = NULL
+    `);
+    attachments.forEach((attachment, index) => {
+        const storageKey = normalizeAttachmentStorageKey(typeof attachment === 'string' ? attachment : attachment.path, typeof attachment === 'string' ? null : attachment.fsPath);
+        if (!storageKey)
+            return;
+        const row = selectAsset.get(deps.tenantId, normalizedWorkspaceId, storageKey);
+        const assetId = String(row?.asset_id || '').trim()
+            || ((/^https?:\/\//i.test(storageKey) || (typeof attachment !== 'string' && typeof attachment.fsPath === 'string' && attachment.fsPath.trim().length > 0))
+                ? ensureExternalReferenceAsset(deps, storageKey, normalizedWorkspaceId, attachment)
+                : '');
+        if (!assetId)
+            return;
+        const role = /^https?:\/\//i.test(storageKey)
+            ? 'reference'
+            : String(row?.kind || '').trim() === 'image'
+                ? 'image'
+                : 'attachment';
+        const displayName = String(row?.kind || '').trim() === 'document'
+            ? null
+            : (typeof attachment === 'string'
+                ? null
+                : buildAttachmentDisplayName(attachment, /^https?:\/\//i.test(storageKey) ? null : path.basename(storageKey)));
+        const timestamp = typeof attachment === 'string' ? new Date().toISOString() : (attachment.timestamp || new Date().toISOString());
+        upsertLink.run(deps.tenantId, normalizedWorkspaceId, assetId, normalizedTaskId, role, displayName, index, timestamp, timestamp);
+    });
+}

package/dist/core/AuthTokenService.d.ts

@@ -0,0 +1,44 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+import type { AuthTokenPurpose, AuthTokenInspection } from './types.js';
+/**
+ * Handles one-time auth token lifecycle (email verification, password reset, invite acceptance)
+ * and the thin read/write helpers for email-verification and password state.
+ */
+export declare class AuthTokenService {
+    private readonly db;
+    private readonly tenantId;
+    constructor(db: DatabaseAdapter, tenantId: string);
+    private generateEntityId;
+    createOneTimeAuthToken(userId: string, purpose: AuthTokenPurpose, ttlSeconds: number, workspaceId?: string | null): string;
+    consumeOneTimeAuthToken(token: string, purpose: AuthTokenPurpose): {
+        userId: string;
+        workspaceId?: string;
+    } | null;
+    inspectOneTimeAuthToken(token: string, purpose: AuthTokenPurpose): AuthTokenInspection;
+    isEmailVerified(email: string): boolean;
+    markEmailVerified(email: string): boolean;
+    requestEmailVerification(input: {
+        email: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    verifyEmailWithToken(token: string): boolean;
+    requestPasswordReset(input: {
+        email: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    requestInviteAcceptance(input: {
+        userId: string;
+        workspaceId: string;
+        ttlSeconds?: number;
+    }): {
+        token?: string;
+    };
+    resetPasswordWithToken(input: {
+        token: string;
+        password: string;
+    }): boolean;
+}