@taskforcehq/taskforce 0.3.309 → 0.3.313

package/dist/core/Taskforce.listTasksSlim.test.js

@@ -1,91 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { TaskforceCore } from './Taskforce';
-const createdRoots = [];
-const originalHome = process.env.HOME;
-function createProjectRoot(prefix = 'taskforce-list-tasks-slim-') {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    process.env.HOME = root;
-    createdRoots.push(root);
-    return root;
-}
-afterEach(() => {
-    process.env.HOME = originalHome;
-    while (createdRoots.length > 0) {
-        const root = createdRoots.pop();
-        if (root && fs.existsSync(root)) {
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    }
-});
-describe('TaskforceCore.listTasksSlim', () => {
-    it('does not hydrate comments, task events, attachments, or checklist items', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const task = core.createTask({ title: 'Heavy task' }, { workspaceId: 'default' });
-        core.addComment(task.id, 'note from reviewer', 'user', 'default');
-        core.replaceChecklistItems(task.id, [{ title: 'step one', isCompleted: false }], 'default');
-        const slim = core.listTasksSlim('default');
-        const entry = slim.find((t) => t.id === task.id);
-        expect(entry).toBeDefined();
-        expect(entry).not.toHaveProperty('comments');
-        expect(entry).not.toHaveProperty('taskEvents');
-        expect(entry).not.toHaveProperty('activity');
-        expect(entry).not.toHaveProperty('attachments');
-        expect(entry).not.toHaveProperty('checklistItems');
-        expect(entry).not.toHaveProperty('description');
-        expect(entry).not.toHaveProperty('createdByActor');
-        expect(entry).not.toHaveProperty('assigneeActor');
-        expect(entry).toMatchObject({
-            id: task.id,
-            title: 'Heavy task',
-        });
-    });
-    it('pushes assignee, status, openOnly, type, and priority filters into the query', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const mine = core.createTask({ title: 'Mine open', status: 'in-progress', assignee: 'user-a', priority: 3, type: 'issue' }, { workspaceId: 'default' });
-        core.createTask({ title: 'Other assigned', status: 'task', assignee: 'user-b', priority: 3 }, { workspaceId: 'default' });
-        const mineDone = core.createTask({ title: 'Mine done', status: 'done', assignee: 'user-a', priority: 1 }, { workspaceId: 'default' });
-        core.createTask({ title: 'Mine unassigned' }, { workspaceId: 'default' });
-        const byAssignee = core.listTasksSlim('default', { assignee: 'user-a' }).map((t) => t.id);
-        expect(byAssignee).toEqual(expect.arrayContaining([mine.id, mineDone.id]));
-        expect(byAssignee).toHaveLength(2);
-        const openOnly = core.listTasksSlim('default', { assignee: 'user-a', openOnly: true }).map((t) => t.id);
-        expect(openOnly).toEqual([mine.id]);
-        const byStatus = core.listTasksSlim('default', { status: 'done' }).map((t) => t.id);
-        expect(byStatus).toEqual([mineDone.id]);
-        const byType = core.listTasksSlim('default', { type: 'issue' }).map((t) => t.id);
-        expect(byType).toEqual([mine.id]);
-        const byPriority = core.listTasksSlim('default', { priority: 3 }).map((t) => t.id).sort();
-        expect(byPriority).toHaveLength(2);
-        const byCategory = core.listTasksSlim('default', { category: 'default' }).map((t) => t.id);
-        expect(byCategory).toHaveLength(4);
-    });
-    it('matches unassigned filter against null, empty-string, and "unassigned" values', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const unassigned = core.createTask({ title: 'no one' }, { workspaceId: 'default' });
-        const assigned = core.createTask({ title: 'someone', assignee: 'user-x' }, { workspaceId: 'default' });
-        const db = core.getDatabaseAdapter();
-        // Inject a row with assignee stored as empty string to exercise the fallback branch.
-        db.prepare(`UPDATE tasks SET assignee = '' WHERE id = ?`).run(unassigned.id);
-        const results = core.listTasksSlim('default', { assignee: 'unassigned' }).map((t) => t.id);
-        expect(results).toContain(unassigned.id);
-        expect(results).not.toContain(assigned.id);
-    });
-    it('applies sort, order, and limit in SQL', () => {
-        const projectRoot = createProjectRoot();
-        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
-        const low = core.createTask({ title: 'low', priority: 1 }, { workspaceId: 'default' });
-        const mid = core.createTask({ title: 'mid', priority: 2 }, { workspaceId: 'default' });
-        const high = core.createTask({ title: 'high', priority: 4 }, { workspaceId: 'default' });
-        const byPriorityDesc = core.listTasksSlim('default', { sort: 'priority', order: 'desc' }).map((t) => t.id);
-        expect(byPriorityDesc.slice(0, 3)).toEqual([high.id, mid.id, low.id]);
-        const limited = core.listTasksSlim('default', { sort: 'priority', order: 'desc', limit: 1 });
-        expect(limited).toHaveLength(1);
-        expect(limited[0]?.id).toBe(high.id);
-    });
-});

package/dist/core/Taskforce.mcpAuth.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/Taskforce.mcpAuth.test.js

@@ -1,450 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { createHash, randomBytes } from 'crypto';
-import Database from 'better-sqlite3';
-import { TaskforceCore } from './Taskforce';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-auth-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-function setupWorkspace(core, userId = 'owner-1', workspaceId = 'workspace-1') {
-    Object.defineProperty(core, 'getAccountAccessStatus', {
-        configurable: true,
-        value: () => ({
-            gate: 'ok',
-            hasEntitlement: true,
-            canAccessApp: true,
-            canAccessPlans: true,
-            planSelectionRequired: false,
-            message: null,
-            entitlement: null
-        })
-    });
-    core.createWorkspace({ workspaceId, name: 'Workspace 1' });
-    core.ensureBootstrapUserAccess({
-        userId,
-        workspaceId,
-        role: 'owner',
-        email: `${userId}@example.com`
-    });
-}
-function createOauthGrantToken(core, userId, workspaceId) {
-    const redirectUri = 'https://chat.openai.com/aip/callback';
-    const client = core.registerMcpOAuthClient({
-        provider: 'chatgpt',
-        clientName: 'ChatGPT Connector',
-        redirectUris: [redirectUri]
-    });
-    const verifier = randomBytes(32).toString('base64url');
-    const codeChallenge = createHash('sha256').update(verifier).digest('base64url');
-    const issued = core.issueMcpOAuthAuthorizationCode({
-        provider: 'chatgpt',
-        clientId: client.id,
-        userId,
-        workspaceId,
-        scopes: ['tasks:read'],
-        redirectUri,
-        codeChallenge,
-        codeChallengeMethod: 'S256'
-    });
-    const exchanged = core.exchangeMcpOAuthAuthorizationCode({
-        provider: 'chatgpt',
-        clientId: client.id,
-        code: issued.code,
-        redirectUri,
-        codeVerifier: verifier
-    });
-    return exchanged.accessToken;
-}
-describe('TaskforceCore MCP auth invalidation', () => {
-    it('boots against a legacy mcp_audit_logs table before adding outcome metadata columns', () => {
-        const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-audit-legacy-boot-'));
-        const storagePath = path.join(projectRoot, '.taskforce');
-        fs.mkdirSync(storagePath, { recursive: true });
-        const dbPath = path.join(storagePath, 'taskforce.db');
-        const legacyDb = new Database(dbPath);
-        try {
-            legacyDb.exec(`
-                CREATE TABLE IF NOT EXISTS mcp_audit_logs (
-                    id TEXT PRIMARY KEY,
-                    tenant_id TEXT NOT NULL DEFAULT 'default',
-                    workspace_id TEXT NOT NULL DEFAULT 'default',
-                    actor_type TEXT NOT NULL,
-                    actor_user_id TEXT NOT NULL,
-                    token_id TEXT,
-                    tool_name TEXT NOT NULL,
-                    details_json TEXT,
-                    created_at TEXT NOT NULL
-                );
-                CREATE INDEX IF NOT EXISTS idx_mcp_audit_logs_workspace_created
-                    ON mcp_audit_logs(tenant_id, workspace_id, created_at);
-                CREATE INDEX IF NOT EXISTS idx_mcp_audit_logs_tool_created
-                    ON mcp_audit_logs(tenant_id, tool_name, created_at);
-            `);
-        }
-        finally {
-            legacyDb.close();
-        }
-        const core = new TaskforceCore({ projectRoot, storagePath });
-        try {
-            const columns = core.db.prepare(`PRAGMA table_info(mcp_audit_logs)`).all();
-            expect(columns.some((column) => column.name === 'outcome')).toBe(true);
-            expect(columns.some((column) => column.name === 'reason_code')).toBe(true);
-        }
-        finally {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('backfills MCP audit metadata columns from legacy details_json on reopen', () => {
-        const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-mcp-audit-backfill-'));
-        const storagePath = path.join(projectRoot, '.taskforce');
-        const core = new TaskforceCore({ projectRoot, storagePath });
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.db.prepare(`
-                INSERT INTO mcp_audit_logs (
-                    id, tenant_id, workspace_id, actor_type, actor_user_id, token_id, tool_name, details_json, created_at
-                )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-            `).run('mcp-audit-legacy', 'default', 'workspace-1', 'token', 'owner-1', 'token-legacy', 'create_task', JSON.stringify({
-                requestId: 'req-legacy',
-                ip: '10.0.0.1',
-                userAgent: 'legacy-client',
-                outcome: 'deny',
-                reasonCode: 'scope_denied',
-                scopes: ['tasks:read']
-            }), new Date().toISOString());
-            core.close();
-            const reopened = new TaskforceCore({ projectRoot, storagePath });
-            try {
-                const row = reopened.db.prepare(`
-                    SELECT request_id, ip, user_agent, outcome, reason_code, details_json
-                    FROM mcp_audit_logs
-                    WHERE tenant_id = ? AND id = ?
-                    LIMIT 1
-                `).get('default', 'mcp-audit-legacy');
-                expect(row?.request_id).toBe('req-legacy');
-                expect(row?.ip).toBe('10.0.0.1');
-                expect(row?.user_agent).toBe('legacy-client');
-                expect(row?.outcome).toBe('deny');
-                expect(row?.reason_code).toBe('scope_denied');
-                expect(JSON.parse(String(row?.details_json || '{}'))).toEqual({
-                    requestId: 'req-legacy',
-                    ip: '10.0.0.1',
-                    userAgent: 'legacy-client',
-                    outcome: 'deny',
-                    reasonCode: 'scope_denied',
-                    scopes: ['tasks:read']
-                });
-            }
-            finally {
-                reopened.close();
-            }
-        }
-        finally {
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    });
-    it('stores MCP audit request metadata in first-class columns', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.addMcpAuditLog({
-                workspaceId: 'workspace-1',
-                actorType: 'token',
-                actorUserId: 'owner-1',
-                tokenId: 'token-1',
-                toolName: 'create_task',
-                details: {
-                    requestId: 'req-123',
-                    ip: '127.0.0.1',
-                    userAgent: 'vitest',
-                    outcome: 'deny',
-                    reasonCode: 'scope_denied',
-                    scopes: ['tasks:read']
-                }
-            });
-            const row = core.db.prepare(`
-                SELECT request_id, ip, user_agent, outcome, reason_code, details_json
-                FROM mcp_audit_logs
-                WHERE tenant_id = ? AND workspace_id = ?
-                ORDER BY created_at DESC
-                LIMIT 1
-            `).get('default', 'workspace-1');
-            expect(row?.request_id).toBe('req-123');
-            expect(row?.ip).toBe('127.0.0.1');
-            expect(row?.user_agent).toBe('vitest');
-            expect(row?.outcome).toBe('deny');
-            expect(row?.reason_code).toBe('scope_denied');
-            expect(JSON.parse(String(row?.details_json || '{}'))).toEqual({
-                scopes: ['tasks:read']
-            });
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('uses a postgres-safe bucket value for MCP rate limit windows', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const result = core.checkMcpRateLimit({
-                scope: 'actor',
-                key: 'actor:test',
-                limit: 10,
-                windowMs: 60_000,
-                nowMs: 1_773_703_620_000,
-            });
-            expect(result.allowed).toBe(true);
-            const row = core.db.prepare(`
-                SELECT window_started_at, request_count
-                FROM mcp_rate_limit_windows
-                WHERE tenant_id = ?
-                  AND scope = ?
-                  AND rate_key = ?
-                LIMIT 1
-            `).get('default', 'actor', 'actor:test');
-            expect(row?.request_count).toBe(1);
-            expect(Number(row?.window_started_at)).toBeLessThan(2_147_483_647);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('denies PAT authentication after workspace member is disabled', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const issued = core.createMcpAccessToken({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                name: 'Test Token',
-                scopes: ['tasks:read']
-            });
-            expect(core.authenticateMcpAccessToken(issued.token)?.status).toBe('active');
-            expect(core.setWorkspaceUserDisabled('member-1', 'workspace-1', true)).toBe(true);
-            expect(core.authenticateMcpAccessToken(issued.token)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('denies PAT authentication after workspace membership is removed', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const issued = core.createMcpAccessToken({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                name: 'Member Token',
-                scopes: ['tasks:read']
-            });
-            expect(core.authenticateMcpAccessToken(issued.token)?.status).toBe('active');
-            expect(core.removeWorkspaceUser('member-1', 'workspace-1')).toBe(true);
-            expect(core.authenticateMcpAccessToken(issued.token)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('denies PAT authentication after the workspace is deleted', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            const issued = core.createMcpAccessToken({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                name: 'Workspace Token',
-                scopes: ['tasks:read']
-            });
-            expect(core.authenticateMcpAccessToken(issued.token)?.status).toBe('active');
-            core.deleteWorkspace({ workspaceId: 'workspace-1' });
-            expect(core.authenticateMcpAccessToken(issued.token)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('does not delete active MCP access tokens', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            const issued = core.createMcpAccessToken({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                name: 'Active Token',
-                scopes: ['tasks:read']
-            });
-            expect(() => core.deleteMcpAccessToken({
-                actorUserId: 'owner-1',
-                workspaceId: 'workspace-1',
-                tokenId: issued.record.id
-            })).toThrow('Active MCP tokens must be revoked before deletion');
-            expect(core.listMcpAccessTokens({ userId: 'owner-1', workspaceId: 'workspace-1' }).items).toHaveLength(1);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('deletes revoked MCP access token records', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            const issued = core.createMcpAccessToken({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                name: 'Revoked Token',
-                scopes: ['tasks:read']
-            });
-            core.revokeMcpAccessToken({
-                actorUserId: 'owner-1',
-                workspaceId: 'workspace-1',
-                tokenId: issued.record.id
-            });
-            expect(core.deleteMcpAccessToken({
-                actorUserId: 'owner-1',
-                workspaceId: 'workspace-1',
-                tokenId: issued.record.id
-            })).toBe(true);
-            expect(core.listMcpAccessTokens({ userId: 'owner-1', workspaceId: 'workspace-1' }).items).toHaveLength(0);
-            expect(core.authenticateMcpAccessToken(issued.token)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('deletes expired MCP access token records', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            const issued = core.createMcpAccessToken({
-                userId: 'owner-1',
-                workspaceId: 'workspace-1',
-                name: 'Expired Token',
-                scopes: ['tasks:read'],
-                expiresAt: new Date(Date.now() + 60_000).toISOString()
-            });
-            core.db.prepare(`
-                UPDATE mcp_access_tokens
-                SET expires_at = ?
-                WHERE tenant_id = ? AND id = ?
-            `).run(new Date(Date.now() - 60_000).toISOString(), 'default', issued.record.id);
-            expect(core.listMcpAccessTokens({ userId: 'owner-1', workspaceId: 'workspace-1' }).items[0]?.status).toBe('expired');
-            expect(core.deleteMcpAccessToken({
-                actorUserId: 'owner-1',
-                workspaceId: 'workspace-1',
-                tokenId: issued.record.id
-            })).toBe(true);
-            expect(core.listMcpAccessTokens({ userId: 'owner-1', workspaceId: 'workspace-1' }).items).toHaveLength(0);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('denies OAuth authentication after the authorized member is disabled', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const accessToken = createOauthGrantToken(core, 'member-1', 'workspace-1');
-            expect(core.authenticateMcpOAuthAccessToken(accessToken)?.status).toBe('active');
-            expect(core.setWorkspaceUserDisabled('member-1', 'workspace-1', true)).toBe(true);
-            expect(core.authenticateMcpOAuthAccessToken(accessToken)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('returns persisted AI profile binding on OAuth connector authentication', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            const accessToken = createOauthGrantToken(core, 'owner-1', 'workspace-1');
-            const auth = core.authenticateMcpOAuthAccessToken(accessToken);
-            expect(auth?.aiProfileToken).toBeFalsy();
-            const resolved = core.resolveAiProfile({
-                workspaceId: 'workspace-1',
-                name: 'Codex Connector',
-                icon: 'Code',
-                color: '#0ea5e9',
-            }, {
-                trustedSeatScope: 'cloud_metered',
-            });
-            expect(core.bindMcpOAuthConnectorGrantAiProfile({
-                grantId: auth.grantId,
-                workspaceId: 'workspace-1',
-                profileId: resolved.profile.id,
-                profileToken: resolved.profile.profileToken,
-                profileName: resolved.profile.name,
-            })).toBe(true);
-            expect(core.authenticateMcpOAuthAccessToken(accessToken)).toEqual(expect.objectContaining({
-                grantId: auth.grantId,
-                aiProfileId: resolved.profile.id,
-                aiProfileToken: resolved.profile.profileToken,
-                aiProfileName: 'Codex Connector',
-            }));
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('denies OAuth authentication after account access is suspended', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            setupWorkspace(core, 'owner-1', 'workspace-1');
-            core.ensureBootstrapUserAccess({
-                userId: 'member-1',
-                workspaceId: 'workspace-1',
-                role: 'member',
-                email: 'member@example.com'
-            });
-            const accessToken = createOauthGrantToken(core, 'member-1', 'workspace-1');
-            expect(core.authenticateMcpOAuthAccessToken(accessToken)?.status).toBe('active');
-            Object.defineProperty(core, 'getAccountAccessStatus', {
-                configurable: true,
-                value: () => ({
-                    gate: 'missing_entitlement',
-                    hasEntitlement: false,
-                    canAccessApp: false,
-                    canAccessPlans: true,
-                    planSelectionRequired: false,
-                    message: 'Suspended for test',
-                    entitlement: null
-                })
-            });
-            expect(core.authenticateMcpOAuthAccessToken(accessToken)).toBeNull();
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/Taskforce.realtimeMutation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/core/Taskforce.realtimeMutation.test.js

@@ -1,131 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { TaskforceCore } from './Taskforce';
-function makeCore() {
-    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-realtime-mutation-test-'));
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: path.join(projectRoot, '.taskforce')
-    });
-    return {
-        core,
-        cleanup: () => {
-            core.close();
-            fs.rmSync(projectRoot, { recursive: true, force: true });
-        }
-    };
-}
-describe('TaskforceCore realtime mutation stream', () => {
-    it('does not create task-data directories during core startup', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const paths = core.getPaths();
-            expect(fs.existsSync(path.join(paths.basePath, 'task-data'))).toBe(false);
-            expect(fs.existsSync(path.join(paths.basePath, 'task-data', '_unassigned', 'attachments'))).toBe(false);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('emits task upsert events for create and update paths (MCP/HTTP shared core)', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const events = [];
-            const off = core.onRealtimeMutation((event) => events.push(event));
-            const created = core.createTask({ title: 'Realtime Mutation Task' }, { workspaceId: 'workspace-a' });
-            core.updateTask(created.id, { description: 'updated via core' }, 'workspace-a');
-            off();
-            const taskEvents = events.filter((event) => event.entityType === 'task');
-            expect(taskEvents.length).toBe(2);
-            expect(taskEvents[0].changeType).toBe('upsert');
-            expect(taskEvents[0].workspaceId).toBe('workspace-a');
-            expect(taskEvents[0].entityIds).toContain(created.id);
-            expect(taskEvents[1].seq).toBeGreaterThan(taskEvents[0].seq);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('emits a task upsert event when adding a comment', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const task = core.createTask({ title: 'Realtime comment task' }, { workspaceId: 'workspace-a' });
-            const events = [];
-            const off = core.onRealtimeMutation((event) => events.push(event));
-            core.addComment(task.id, 'Fresh comment', 'user', 'workspace-a');
-            off();
-            const taskEvent = events.find((event) => event.entityType === 'task');
-            expect(taskEvent).toBeTruthy();
-            expect(taskEvent?.changeType).toBe('upsert');
-            expect(taskEvent?.workspaceId).toBe('workspace-a');
-            expect(taskEvent?.entityIds).toContain(task.id);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('emits taxonomy events on taxonomy updates', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const events = [];
-            const off = core.onRealtimeMutation((event) => events.push(event));
-            core.updateTaxonomies([{ value: 'streaming', label: 'Streaming' }], 'workspace-a');
-            off();
-            const taxonomyEvent = events.find((event) => event.entityType === 'taxonomy');
-            expect(taxonomyEvent).toBeTruthy();
-            expect(taxonomyEvent?.workspaceId).toBe('workspace-a');
-            expect(taxonomyEvent?.changeType).toBe('upsert');
-            expect(taxonomyEvent?.entityIds).toContain('__taxonomy_config__');
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('emits document metadata events and avoids duplicate emits for unchanged hash', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const events = [];
-            const off = core.onRealtimeMutation((event) => events.push(event));
-            core.upsertDocumentWatermark('workspace-docs', '.taskforce/docs/foo.md', 'hash-1', new Date().toISOString());
-            core.upsertDocumentWatermark('workspace-docs', '.taskforce/docs/foo.md', 'hash-1', new Date().toISOString());
-            core.deleteDocumentWatermark('workspace-docs', '.taskforce/docs/foo.md');
-            off();
-            const docEvents = events.filter((event) => event.entityType === 'document-metadata');
-            expect(docEvents.length).toBe(2);
-            expect(docEvents[0].changeType).toBe('upsert');
-            expect(docEvents[1].changeType).toBe('delete');
-            expect(docEvents.every((event) => event.workspaceId === 'workspace-docs')).toBe(true);
-        }
-        finally {
-            cleanup();
-        }
-    });
-    it('emits document metadata events for explicit asset/document invalidation notifications', () => {
-        const { core, cleanup } = makeCore();
-        try {
-            const events = [];
-            const off = core.onRealtimeMutation((event) => events.push(event));
-            core.notifyDocumentMetadataMutation('workspace-docs', [
-                'workspaces/workspace-docs/assets/documents/asset-doc.md',
-                'workspaces/workspace-docs/assets/files/asset-file.txt'
-            ], 'upsert');
-            off();
-            expect(events).toEqual([
-                expect.objectContaining({
-                    workspaceId: 'workspace-docs',
-                    entityType: 'document-metadata',
-                    changeType: 'upsert',
-                    entityIds: [
-                        'workspaces/workspace-docs/assets/documents/asset-doc.md',
-                        'workspaces/workspace-docs/assets/files/asset-file.txt'
-                    ]
-                })
-            ]);
-        }
-        finally {
-            cleanup();
-        }
-    });
-});

package/dist/core/UserProfileAvatarDrafts.test.d.ts

@@ -1 +0,0 @@
-export {};