@taskforcehq/taskforce 0.3.170 → 0.3.301

package/dist/core/TaskActivityService.js

@@ -0,0 +1,130 @@
+function normalizeTaskEventActor(deps, actorRef, workspaceId) {
+    const actorProfile = deps.resolveWorkspaceActor(workspaceId, actorRef);
+    const actor = String(actorRef || '').trim() || 'system';
+    if (actor === 'system') {
+        return { actor, actorType: 'system', actorProfile: null };
+    }
+    return {
+        actor,
+        actorType: actorProfile?.kind === 'ai' ? 'ai' : actorProfile?.kind === 'human' ? 'human' : 'system',
+        actorProfile
+    };
+}
+function normalizeTaskEventDetails(details) {
+    if (!details || typeof details !== 'object' || Array.isArray(details))
+        return {};
+    return details;
+}
+function mapTaskEventRow(deps, row) {
+    const workspaceId = deps.normalizeWorkspaceId(typeof row.workspace_id === 'string' ? row.workspace_id : undefined);
+    const actor = String(row.actor || 'system').trim() || 'system';
+    let details = {};
+    try {
+        details = normalizeTaskEventDetails(row.details_json ? JSON.parse(String(row.details_json)) : {});
+    }
+    catch {
+        details = {};
+    }
+    return {
+        id: String(row.id || '').trim(),
+        taskId: String(row.task_id || '').trim(),
+        workspaceId,
+        action: String(row.action || '').trim(),
+        actor,
+        actorType: row.actor_type === 'ai' || row.actor_type === 'human' || row.actor_type === 'system'
+            ? row.actor_type
+            : 'system',
+        createdAt: String(row.created_at || ''),
+        details,
+        actorProfile: actor === 'system' ? null : deps.resolveWorkspaceActor(workspaceId, actor)
+    };
+}
+export function replaceTaskCommentsService(deps, taskId, workspaceId, comments) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    deps.db.prepare('DELETE FROM comments WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?')
+        .run(deps.tenantId, normalizedWorkspaceId, taskId);
+    if (comments.length === 0)
+        return;
+    const insertComment = deps.db.prepare(`
+        INSERT INTO comments (id, tenant_id, workspace_id, task_id, text, author, submitted_author, timestamp)
+        VALUES (@id, @tenant_id, @workspace_id, @task_id, @text, @author, @submitted_author, @timestamp)
+    `);
+    for (const comment of comments) {
+        insertComment.run({
+            id: comment.id,
+            tenant_id: deps.tenantId,
+            workspace_id: normalizedWorkspaceId,
+            task_id: taskId,
+            text: comment.text,
+            author: comment.author,
+            submitted_author: comment.submittedAuthor || comment.author,
+            timestamp: comment.timestamp
+        });
+    }
+}
+export function listTaskEventsInternalService(deps, taskId, workspaceId) {
+    const rows = deps.db.prepare(`
+        SELECT id, task_id, workspace_id, action, actor, actor_type, details_json, created_at
+        FROM task_events
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+          AND task_id = ?
+        ORDER BY created_at ASC, id ASC
+    `).all(deps.tenantId, workspaceId, taskId);
+    return rows.map((row) => mapTaskEventRow(deps, row));
+}
+export function buildTaskActivityService(comments, taskEvents) {
+    const visibleTaskEvents = taskEvents.filter((event) => event.action !== 'task-comment-added');
+    return [
+        ...comments.map((comment) => ({
+            id: `comment:${comment.id}`,
+            type: 'comment',
+            timestamp: comment.timestamp,
+            comment
+        })),
+        ...visibleTaskEvents.map((event) => ({
+            id: `event:${event.id}`,
+            type: 'event',
+            timestamp: event.createdAt,
+            event
+        }))
+    ].sort((left, right) => {
+        const leftTs = Date.parse(String(left.timestamp || ''));
+        const rightTs = Date.parse(String(right.timestamp || ''));
+        if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
+            return leftTs - rightTs;
+        }
+        return String(left.id || '').localeCompare(String(right.id || ''));
+    });
+}
+export function addTaskEventService(deps, input) {
+    const action = String(input.action || '').trim();
+    if (!action)
+        return;
+    const taskId = String(input.taskId || '').trim();
+    if (!taskId)
+        return;
+    const workspaceId = deps.normalizeWorkspaceId(input.workspaceId);
+    const createdAt = String(input.createdAt || '').trim() || new Date().toISOString();
+    const { actor, actorType } = normalizeTaskEventActor(deps, input.actor, workspaceId);
+    deps.db.prepare(`
+        INSERT INTO task_events (
+            id, tenant_id, workspace_id, task_id, action, actor, actor_type, details_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(deps.generateEntityId('task-event'), deps.tenantId, workspaceId, taskId, action, actor, actorType, JSON.stringify(normalizeTaskEventDetails(input.details)), createdAt);
+}
+export function replaceTaskEventsService(deps, taskId, workspaceId, taskEvents) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    deps.db.prepare('DELETE FROM task_events WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?')
+        .run(deps.tenantId, normalizedWorkspaceId, taskId);
+    if (taskEvents.length === 0)
+        return;
+    const insertTaskEvent = deps.db.prepare(`
+        INSERT INTO task_events (
+            id, tenant_id, workspace_id, task_id, action, actor, actor_type, details_json, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const event of taskEvents) {
+        insertTaskEvent.run(event.id, deps.tenantId, normalizedWorkspaceId, taskId, event.action, event.actor, event.actorType, JSON.stringify(normalizeTaskEventDetails(event.details)), event.createdAt);
+    }
+}

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

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

package/dist/core/TaskAttachmentsCanonical.test.js

@@ -0,0 +1,306 @@
+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-canonical-attachments-') {
+    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 canonical task attachments', () => {
+    it('renders canonical asset links as task attachments', () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = core.createTask({
+            title: 'Attachment task'
+        }, { workspaceId: 'default' });
+        const db = core.getDatabaseAdapter();
+        const now = new Date().toISOString();
+        const storageKey = 'workspaces/default/assets/documents/asset-doc-1-implementation-plan.md';
+        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, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-doc-1', 'default', 'default', 'document', 'Implementation Plan', 'implementation-plan.md', 'text/markdown', 'r2', storageKey, 'sha-doc-1', 120, 'doc-1', 1, 1, 'clean', now, now);
+        db.prepare(`
+            INSERT INTO workspace_asset_links (
+                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run('default', 'default', 'asset-doc-1', created.id, 'attachment', now, now);
+        const tasks = core.listTasks('default').tasks;
+        const task = tasks.find((entry) => entry.id === created.id);
+        expect(task?.attachments).toEqual([
+            expect.objectContaining({
+                path: '/api/taskforce/documents/asset-doc-1/content',
+                fsPath: storageKey,
+                caption: 'Implementation Plan',
+                assetId: 'asset-doc-1'
+            })
+        ]);
+    });
+    it('writes canonical task attachment links when attachments are updated from payload data', () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = core.createTask({
+            title: 'Attachment write task'
+        }, { workspaceId: 'default' });
+        const db = core.getDatabaseAdapter();
+        const now = new Date().toISOString();
+        const storageKey = 'workspaces/default/assets/files/asset-file-1-brief.pdf';
+        db.prepare(`
+            INSERT INTO workspace_assets (
+                asset_id, tenant_id, workspace_id, kind, original_filename, mime_type,
+                storage_provider, storage_key, content_sha256, size_bytes, is_latest,
+                scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-file-1', 'default', 'default', 'file', 'brief.pdf', 'application/pdf', 'r2', storageKey, 'sha-file-1', 88, 1, 'clean', now, now);
+        core.updateTask(created.id, {
+            attachments: [{
+                    path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
+                    fsPath: storageKey,
+                    caption: 'Brief',
+                    timestamp: now
+                }]
+        }, 'default');
+        const rows = db.prepare(`
+            SELECT asset_id, task_id, role, deleted_at
+            FROM workspace_asset_links
+            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
+        `).all('default', 'default', created.id);
+        expect(rows).toEqual([
+            expect.objectContaining({
+                asset_id: 'asset-file-1',
+                task_id: created.id,
+                role: 'attachment',
+                deleted_at: null
+            })
+        ]);
+    });
+    it('renders canonical image attachments through the unified context route', () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = core.createTask({
+            title: 'Image attachment task'
+        }, { workspaceId: 'default' });
+        const db = core.getDatabaseAdapter();
+        const now = new Date().toISOString();
+        const storageKey = 'workspaces/default/assets/images/asset-image-1-proof.png';
+        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, is_latest, scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-image-1', 'default', 'default', 'image', 'Proof', 'proof.png', 'image/png', 'local', storageKey, 'sha-image-1', 42, 1, 'clean', now, now);
+        db.prepare(`
+            INSERT INTO workspace_asset_links (
+                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run('default', 'default', 'asset-image-1', created.id, 'image', now, now);
+        const assetPath = path.join(projectRoot, '.taskforce', storageKey);
+        fs.mkdirSync(path.dirname(assetPath), { recursive: true });
+        fs.writeFileSync(assetPath, 'png');
+        const task = core.getTask(created.id, 'default');
+        expect(task?.attachments).toEqual([
+            expect.objectContaining({
+                path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
+                fsPath: storageKey,
+                caption: 'Proof',
+                referenceNumber: 1,
+                referenceLabel: 'I-1',
+            })
+        ]);
+    });
+    it('retires image notes sessions when an image attachment is removed from a task', () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = core.createTask({
+            title: 'Detached image cleanup task'
+        }, { workspaceId: 'default', actorRef: 'user' });
+        const db = core.getDatabaseAdapter();
+        const now = new Date().toISOString();
+        const imageStorageKey = 'workspaces/default/assets/images/asset-image-detach-proof.png';
+        const fileStorageKey = 'workspaces/default/assets/files/asset-file-keep-brief.pdf';
+        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, is_latest, scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-image-detach', 'default', 'default', 'image', 'Proof', 'proof.png', 'image/png', 'local', imageStorageKey, 'sha-image-detach', 42, 1, 'clean', now, now);
+        db.prepare(`
+            INSERT INTO workspace_assets (
+                asset_id, tenant_id, workspace_id, kind, original_filename, mime_type,
+                storage_provider, storage_key, content_sha256, size_bytes, is_latest, scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-file-keep', 'default', 'default', 'file', 'brief.pdf', 'application/pdf', 'local', fileStorageKey, 'sha-file-keep', 88, 1, 'clean', now, now);
+        db.prepare(`
+            INSERT INTO workspace_asset_links (
+                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run('default', 'default', 'asset-image-detach', created.id, 'image', now, now);
+        core.createAnnotatedAttachmentSession({
+            workspaceId: 'default',
+            taskId: created.id,
+            baseImageAssetId: 'asset-image-detach',
+            title: 'Session to retire',
+            annotations: [
+                { id: 'annotation-1', kind: 'pin', order: 0, instruction: 'Look here', x: 0.3, y: 0.4 },
+            ],
+            actorId: 'user',
+        });
+        core.updateTask(created.id, {
+            attachments: [{
+                    path: `/api/taskforce/context/${encodeURIComponent(fileStorageKey)}`,
+                    fsPath: fileStorageKey,
+                    caption: 'Brief',
+                    timestamp: now
+                }]
+        }, 'default', { actorRef: 'user' });
+        const activeSessions = core.listAnnotatedAttachmentSessions({
+            workspaceId: 'default',
+            taskId: created.id,
+            imageAssetId: 'asset-image-detach',
+        });
+        const allSessions = core.listAnnotatedAttachmentSessions({
+            workspaceId: 'default',
+            taskId: created.id,
+            imageAssetId: 'asset-image-detach',
+            includeDeleted: true,
+        });
+        const activeLinks = db.prepare(`
+            SELECT asset_id, deleted_at
+            FROM workspace_asset_links
+            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ? AND asset_id = ?
+        `).all('default', 'default', created.id, 'asset-image-detach');
+        expect(activeSessions).toEqual([]);
+        expect(allSessions).toHaveLength(1);
+        expect(allSessions[0]?.deletedAt).toBeTruthy();
+        expect(activeLinks).toEqual([
+            expect.objectContaining({
+                asset_id: 'asset-image-detach',
+                deleted_at: expect.any(String),
+            })
+        ]);
+    });
+    it('repairs pre-existing detached image-note sessions on startup without touching unattached sessions', () => {
+        const projectRoot = createProjectRoot();
+        const seedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const created = seedCore.createTask({
+            title: 'Detached image repair task'
+        }, { workspaceId: 'default', actorRef: 'user' });
+        const db = seedCore.getDatabaseAdapter();
+        const now = new Date().toISOString();
+        const imageStorageKey = 'workspaces/default/assets/images/asset-image-repair-proof.png';
+        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, is_latest, scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-image-repair', 'default', 'default', 'image', 'Repair Proof', 'repair-proof.png', 'image/png', 'local', imageStorageKey, 'sha-image-repair', 42, 1, 'clean', now, now);
+        db.prepare(`
+            INSERT INTO workspace_asset_links (
+                tenant_id, workspace_id, asset_id, task_id, role, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `).run('default', 'default', 'asset-image-repair', created.id, 'image', now, now);
+        seedCore.createAnnotatedAttachmentSession({
+            workspaceId: 'default',
+            taskId: created.id,
+            baseImageAssetId: 'asset-image-repair',
+            title: 'Legacy detached session',
+            annotations: [
+                { id: 'annotation-1', kind: 'pin', order: 0, instruction: 'Legacy note', x: 0.3, y: 0.4 },
+            ],
+            actorId: 'user',
+        });
+        seedCore.createAnnotatedAttachmentSession({
+            workspaceId: 'default',
+            taskId: '',
+            baseImageAssetId: 'asset-image-repair',
+            title: 'Intentional unattached session',
+            annotations: [],
+            actorId: 'user',
+        });
+        db.prepare(`
+            UPDATE workspace_asset_links
+            SET deleted_at = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND task_id = ? AND asset_id = ? AND role = 'image'
+        `).run(now, now, 'default', 'default', created.id, 'asset-image-repair');
+        seedCore.close();
+        const repairedCore = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const detachedSessions = repairedCore.listAnnotatedAttachmentSessions({
+            workspaceId: 'default',
+            taskId: created.id,
+            imageAssetId: 'asset-image-repair',
+            includeDeleted: true,
+        });
+        const unattachedSessions = repairedCore.listAnnotatedAttachmentSessions({
+            workspaceId: 'default',
+            imageAssetId: 'asset-image-repair',
+            includeDeleted: true,
+        }).filter((session) => session.taskId === '');
+        expect(detachedSessions).toHaveLength(1);
+        expect(detachedSessions[0]?.deletedAt).toEqual(expect.any(String));
+        expect(unattachedSessions).toEqual([
+            expect.objectContaining({
+                title: 'Intentional unattached session',
+                deletedAt: null,
+            })
+        ]);
+    });
+    it('preserves attachment links when a synced task snapshot is applied', () => {
+        const projectRoot = createProjectRoot();
+        const core = new TaskforceCore({ projectRoot, storagePath: '.taskforce' });
+        const workspaceId = 'default';
+        const db = core.getDatabaseAdapter();
+        const createdAt = '2026-03-21T13:51:30.000Z';
+        const updatedAt = '2026-03-21T13:51:42.794Z';
+        const storageKey = 'workspaces/default/assets/files/asset-sync-hello.txt';
+        db.prepare(`
+            INSERT INTO workspace_assets (
+                asset_id, tenant_id, workspace_id, kind, original_filename, mime_type,
+                storage_provider, storage_key, content_sha256, size_bytes, is_latest,
+                scan_status, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run('asset-sync-1', 'default', workspaceId, 'file', 'hello.txt', 'text/plain', 'local', storageKey, 'sha-sync-1', 5, 1, 'clean', createdAt, updatedAt);
+        const assetPath = path.join(projectRoot, '.taskforce', storageKey);
+        fs.mkdirSync(path.dirname(assetPath), { recursive: true });
+        fs.writeFileSync(assetPath, 'hello');
+        core.applyWorkspaceSyncSnapshot({
+            tasks: [{
+                    id: 'task-sync-attachment-1',
+                    title: 'Synced attachment task',
+                    status: 'task',
+                    createdAt,
+                    updatedAt,
+                    attachments: [{
+                            path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
+                            fsPath: storageKey,
+                            caption: 'hello.txt',
+                            timestamp: updatedAt
+                        }]
+                }]
+        }, workspaceId);
+        const task = core.getTask('task-sync-attachment-1', workspaceId);
+        expect(task?.attachments).toEqual([
+            expect.objectContaining({
+                path: `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
+                fsPath: storageKey,
+                caption: 'hello.txt'
+            })
+        ]);
+    });
+});

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

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

package/dist/core/TaskAuditTimeline.test.js

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import Database from 'better-sqlite3';
+import { TaskforceCore } from './Taskforce';
+function makeCore() {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-audit-timeline-'));
+    const core = new TaskforceCore({
+        projectRoot,
+        storagePath: path.join(projectRoot, '.taskforce')
+    });
+    return {
+        core,
+        cleanup: () => {
+            core.close();
+            fs.rmSync(projectRoot, { recursive: true, force: true });
+        }
+    };
+}
+describe('TaskforceCore task audit timeline', () => {
+    it('writes a task-created event and exposes it in the task activity feed', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'Audit seed task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            const events = core.listTaskEvents(task.id, 'workspace-a');
+            const hydrated = core.getTask(task.id, 'workspace-a');
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual(expect.objectContaining({
+                action: 'task-created',
+                actor: 'user',
+                actorType: 'human',
+            }));
+            expect(hydrated?.activity?.[0]).toEqual(expect.objectContaining({
+                type: 'event',
+                event: expect.objectContaining({ action: 'task-created' })
+            }));
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('records core task mutation events for update, scheduling, workstream relationships, attachments, comments, archive, and unarchive', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            core.createWorkspace({ workspaceId: 'workspace-a', name: 'Workspace A' });
+            const workstream = core.createWorkstream({ title: 'Tracked workstream' }, 'workspace-a');
+            const task = core.createTask({ title: 'Tracked task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            core.updateTask(task.id, { description: 'Updated body copy' }, 'workspace-a', { actorRef: 'user' });
+            core.updateTask(task.id, { status: 'in-progress' }, 'workspace-a', { actorRef: 'user' });
+            core.updateTask(task.id, { scheduledDate: '2026-03-24' }, 'workspace-a', { actorRef: 'user' });
+            core.updateTask(task.id, { workstreamId: workstream.id }, 'workspace-a', { actorRef: 'user' });
+            core.updateTask(task.id, {
+                attachments: [{ path: 'https://example.com/spec.md', caption: 'spec.md', timestamp: '2026-03-22T12:00:00.000Z' }]
+            }, 'workspace-a', { actorRef: 'user' });
+            core.addComment(task.id, 'This needs follow-up.', 'user', 'workspace-a', { actorRef: 'user' });
+            core.archiveTask(task.id, false, undefined, 'workspace-a', { actorRef: 'user', skipHierarchyCheck: true });
+            core.unarchiveTask(task.id, 'workspace-a', { actorRef: 'user' });
+            const actions = core.listTaskEvents(task.id, 'workspace-a').map((event) => event.action);
+            const commentEvent = core.listTaskEvents(task.id, 'workspace-a').find((event) => event.action === 'task-comment-added');
+            const hydrated = core.getTask(task.id, 'workspace-a');
+            expect(actions).toEqual(expect.arrayContaining([
+                'task-created',
+                'task-updated',
+                'task-status-changed',
+                'task-schedule-changed',
+                'task-relationship-changed',
+                'task-attachments-changed',
+                'task-comment-added',
+                'task-archived',
+                'task-unarchived'
+            ]));
+            expect(commentEvent?.details?.submittedAuthor).toBe('user');
+            expect(hydrated?.activity?.some((item) => item.type === 'event' && item.event.action === 'task-comment-added')).toBe(false);
+            expect(hydrated?.activity?.some((item) => item.type === 'comment' && item.comment.text === 'This needs follow-up.')).toBe(true);
+            expect(hydrated?.comments?.find((item) => item.text === 'This needs follow-up.')?.submittedAuthor).toBe('user');
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('does not write a duplicate task event for no-op updates', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const task = core.createTask({ title: 'No-op task', createdBy: 'user' }, { workspaceId: 'workspace-a', actorRef: 'user' });
+            const before = core.listTaskEvents(task.id, 'workspace-a').length;
+            core.updateTask(task.id, { title: 'No-op task' }, 'workspace-a', { actorRef: 'user' });
+            const after = core.listTaskEvents(task.id, 'workspace-a').length;
+            expect(after).toBe(before);
+        }
+        finally {
+            cleanup();
+        }
+    });
+    it('repairs legacy comments tables so raw submitted authors can be stored', () => {
+        const { core, cleanup } = makeCore();
+        try {
+            const dbPath = path.join(core.getPaths().basePath, 'taskforce.db');
+            core.close();
+            const db = new Database(dbPath);
+            db.exec(`
+                ALTER TABLE comments RENAME TO comments_legacy;
+                CREATE TABLE comments (
+                    id TEXT PRIMARY KEY,
+                    tenant_id TEXT NOT NULL DEFAULT 'default',
+                    workspace_id TEXT NOT NULL DEFAULT 'default',
+                    task_id TEXT NOT NULL,
+                    text TEXT NOT NULL,
+                    author TEXT NOT NULL,
+                    timestamp TEXT NOT NULL,
+                    FOREIGN KEY(task_id) REFERENCES tasks(id) ON DELETE CASCADE
+                );
+                INSERT INTO comments (id, tenant_id, workspace_id, task_id, text, author, timestamp)
+                SELECT id, tenant_id, workspace_id, task_id, text, author, timestamp
+                FROM comments_legacy;
+                DROP TABLE comments_legacy;
+            `);
+            db.close();
+            const reopened = new TaskforceCore({
+                projectRoot: path.dirname(core.getPaths().basePath),
+                storagePath: core.getPaths().basePath
+            });
+            const columns = reopened.db.prepare(`PRAGMA table_info(comments)`).all()
+                .map((column) => column.name);
+            reopened.close();
+            expect(columns).toContain('submitted_author');
+        }
+        finally {
+            cleanup();
+        }
+    });
+});