@taskforcehq/taskforce 0.3.304 → 0.3.306

package/dist/services/workflowExportSnapshots.test.js

@@ -17,6 +17,8 @@ describe('Workflow export snapshots', () => {
         for (const workflowName of workflowNames) {
             it(`${envId}/${workflowName} export snapshot`, () => {
                 const result = engine.processTemplate(workflowName, envId);
+                expect(result.content).not.toContain('shared docs under `docs/`');
+                expect(result.content).not.toContain('store it under `docs/`');
                 expect({
                     filename: result.filename,
                     strategy: result.strategy,

package/dist/shared/aiProfileSeatScope.d.ts

@@ -0,0 +1,5 @@
+export declare const AI_PROFILE_SEAT_SCOPES: readonly ["cloud_metered", "local_unmetered"];
+export type AiProfileSeatScope = typeof AI_PROFILE_SEAT_SCOPES[number];
+export declare function isAiProfileSeatScope(value: unknown): value is AiProfileSeatScope;
+export declare function parseAiProfileSeatScope(value: unknown): AiProfileSeatScope | null;
+export declare function formatAiProfileSeatScopeLabel(value: AiProfileSeatScope): string;

package/dist/shared/aiProfileSeatScope.js

@@ -0,0 +1,21 @@
+export const AI_PROFILE_SEAT_SCOPES = [
+    'cloud_metered',
+    'local_unmetered',
+];
+const AI_PROFILE_SEAT_SCOPE_LABELS = {
+    cloud_metered: 'Cloud MCP',
+    local_unmetered: 'Local MCP',
+};
+export function isAiProfileSeatScope(value) {
+    return typeof value === 'string'
+        && AI_PROFILE_SEAT_SCOPES.includes(value);
+}
+export function parseAiProfileSeatScope(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return isAiProfileSeatScope(normalized) ? normalized : null;
+}
+export function formatAiProfileSeatScopeLabel(value) {
+    return AI_PROFILE_SEAT_SCOPE_LABELS[value];
+}

package/dist/shared/passwordPolicy.d.ts

@@ -0,0 +1,13 @@
+export declare const MIN_PASSWORD_LENGTH = 12;
+export type PasswordPolicyCode = 'PASSWORD_REQUIRED' | 'PASSWORD_TOO_SHORT' | 'PASSWORD_TOO_COMMON' | 'PASSWORD_CONTAINS_PERSONAL_INFO';
+export interface PasswordPolicyResult {
+    ok: boolean;
+    code?: PasswordPolicyCode;
+    message?: string;
+}
+export interface PasswordPolicyContext {
+    email?: string | null;
+    displayName?: string | null;
+}
+export declare function getPasswordPolicyGuidance(): string[];
+export declare function validatePasswordPolicy(password: string, context?: PasswordPolicyContext): PasswordPolicyResult;

package/dist/shared/passwordPolicy.js

@@ -0,0 +1,84 @@
+export const MIN_PASSWORD_LENGTH = 12;
+const COMMON_PASSWORDS = new Set([
+    '12345678',
+    '123456789',
+    '1234567890',
+    'admin123',
+    'changeme',
+    'letmein',
+    'letmein123',
+    'password',
+    'password1',
+    'password12',
+    'password123',
+    'password1234',
+    'qwerty',
+    'qwerty123',
+    'welcome',
+    'welcome123'
+]);
+const normalizeForComparison = (value) => (String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, ''));
+function extractPersonalInfoTokens(context) {
+    const tokens = new Set();
+    const email = String(context?.email || '').trim().toLowerCase();
+    const displayName = String(context?.displayName || '').trim().toLowerCase();
+    if (email.includes('@')) {
+        const localPart = email.split('@')[0] || '';
+        const compactLocalPart = localPart.replace(/[^a-z0-9]/g, '');
+        if (compactLocalPart.length >= 4)
+            tokens.add(compactLocalPart);
+        for (const part of localPart.split(/[^a-z0-9]+/)) {
+            if (part.length >= 4)
+                tokens.add(part);
+        }
+    }
+    for (const part of displayName.split(/[^a-z0-9]+/)) {
+        if (part.length >= 4)
+            tokens.add(part);
+    }
+    return [...tokens];
+}
+export function getPasswordPolicyGuidance() {
+    return [
+        `Use at least ${MIN_PASSWORD_LENGTH} characters.`,
+        'Avoid common passwords or obvious patterns.',
+        'Do not include your email or display name.'
+    ];
+}
+export function validatePasswordPolicy(password, context) {
+    const rawPassword = String(password || '');
+    if (!rawPassword) {
+        return {
+            ok: false,
+            code: 'PASSWORD_REQUIRED',
+            message: 'Password is required.'
+        };
+    }
+    if (rawPassword.length < MIN_PASSWORD_LENGTH) {
+        return {
+            ok: false,
+            code: 'PASSWORD_TOO_SHORT',
+            message: `Password must be at least ${MIN_PASSWORD_LENGTH} characters.`
+        };
+    }
+    const normalizedPassword = normalizeForComparison(rawPassword);
+    if (COMMON_PASSWORDS.has(normalizedPassword)) {
+        return {
+            ok: false,
+            code: 'PASSWORD_TOO_COMMON',
+            message: 'Choose a less common password.'
+        };
+    }
+    const personalTokens = extractPersonalInfoTokens(context);
+    if (personalTokens.some((token) => normalizedPassword.includes(token))) {
+        return {
+            ok: false,
+            code: 'PASSWORD_CONTAINS_PERSONAL_INFO',
+            message: 'Password cannot contain your email or display name.'
+        };
+    }
+    return { ok: true };
+}

package/dist/shared/passwordPolicy.test.d.ts

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

package/dist/shared/passwordPolicy.test.js

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { getPasswordPolicyGuidance, MIN_PASSWORD_LENGTH, validatePasswordPolicy } from './passwordPolicy';
+describe('passwordPolicy', () => {
+    it('describes the active password policy guidance', () => {
+        expect(getPasswordPolicyGuidance()).toEqual([
+            `Use at least ${MIN_PASSWORD_LENGTH} characters.`,
+            'Avoid common passwords or obvious patterns.',
+            'Do not include your email or display name.'
+        ]);
+    });
+    it('rejects common passwords even when padded with punctuation', () => {
+        expect(validatePasswordPolicy('Password123!')).toEqual({
+            ok: false,
+            code: 'PASSWORD_TOO_COMMON',
+            message: 'Choose a less common password.'
+        });
+    });
+    it('rejects passwords containing personal information', () => {
+        expect(validatePasswordPolicy('RossBurkeSecure!2026', {
+            email: 'ross@example.com',
+            displayName: 'Ross Burke'
+        })).toEqual({
+            ok: false,
+            code: 'PASSWORD_CONTAINS_PERSONAL_INFO',
+            message: 'Password cannot contain your email or display name.'
+        });
+    });
+    it('accepts long passwords without common or personal tokens', () => {
+        expect(validatePasswordPolicy('MapleHarborOrbit!2026', {
+            email: 'ross@example.com',
+            displayName: 'Ross Burke'
+        })).toEqual({ ok: true });
+    });
+});

package/dist/storage/workspaceAssetStore.d.ts

@@ -3,6 +3,7 @@ import type { ObjectStorageProvider } from './objectStorage.js';
 export type WorkspaceAssetKind = 'document' | 'image' | 'file';
 export type WorkspaceAssetScanStatus = 'pending' | 'clean' | 'infected' | 'failed';
 export type WorkspaceAssetLinkRole = 'attachment' | 'image' | 'reference';
+export type WorkspaceAssetLinkTargetType = 'task' | 'initiative' | 'workstream';
 export interface WorkspaceAssetEntry {
     assetId: string;
     tenantId: string;
@@ -32,7 +33,9 @@ export interface WorkspaceAssetLinkEntry {
     tenantId: string;
     workspaceId: string;
     assetId: string;
-    taskId: string;
+    targetType: WorkspaceAssetLinkTargetType;
+    targetId: string;
+    taskId: string | null;
     role: WorkspaceAssetLinkRole;
     displayName: string | null;
     sortOrder: number | null;
@@ -43,7 +46,9 @@ export interface WorkspaceAssetLinkEntry {
 export declare class WorkspaceAssetStore {
     private readonly db;
     private readonly tenantId;
+    private supportsTargetTypeCache;
     constructor(db: DatabaseAdapter, tenantId: string);
+    private supportsTargetType;
     private normalizePersistedAsset;
     get(assetIdRaw: string, workspaceIdRaw?: string): WorkspaceAssetEntry | null;
     getByStorageKey(storageKeyRaw: string, workspaceIdRaw: string): WorkspaceAssetEntry | null;
@@ -98,7 +103,9 @@ export declare class WorkspaceAssetStore {
     upsertLink(input: {
         workspaceId: string;
         assetId: string;
-        taskId: string;
+        taskId?: string;
+        targetType?: WorkspaceAssetLinkTargetType;
+        targetId?: string;
         role: WorkspaceAssetLinkRole;
         displayName?: string | null;
         sortOrder?: number | null;
@@ -109,13 +116,18 @@ export declare class WorkspaceAssetStore {
     listLinksForTask(taskIdRaw: string, workspaceIdRaw: string, options?: {
         includeDeleted?: boolean;
     }): WorkspaceAssetLinkEntry[];
+    listLinksForTarget(targetTypeRaw: WorkspaceAssetLinkTargetType, targetIdRaw: string, workspaceIdRaw: string, options?: {
+        includeDeleted?: boolean;
+    }): WorkspaceAssetLinkEntry[];
     listLinksForAsset(assetIdRaw: string, workspaceIdRaw: string, options?: {
         includeDeleted?: boolean;
     }): WorkspaceAssetLinkEntry[];
     deleteLink(input: {
         workspaceId: string;
         assetId: string;
-        taskId: string;
+        taskId?: string;
+        targetType?: WorkspaceAssetLinkTargetType;
+        targetId?: string;
         role: WorkspaceAssetLinkRole;
         hardDelete?: boolean;
     }): boolean;

package/dist/storage/workspaceAssetStore.js

@@ -47,11 +47,15 @@ function mapAssetRow(row) {
     };
 }
 function mapLinkRow(row) {
+    const targetType = String(row.target_type || 'task').trim();
+    const targetId = String(row.task_id || '').trim();
     return {
         tenantId: String(row.tenant_id || 'default'),
         workspaceId: String(row.workspace_id || 'default'),
         assetId: String(row.asset_id || ''),
-        taskId: String(row.task_id || ''),
+        targetType,
+        targetId,
+        taskId: targetType === 'task' ? targetId : null,
         role: String(row.role || 'attachment'),
         displayName: row.display_name == null ? null : String(row.display_name),
         sortOrder: row.sort_order == null ? null : Number(row.sort_order),
@@ -73,10 +77,36 @@ function usesReadableAssetReference(kind) {
 export class WorkspaceAssetStore {
     db;
     tenantId;
+    supportsTargetTypeCache = null;
     constructor(db, tenantId) {
         this.db = db;
         this.tenantId = tenantId;
     }
+    supportsTargetType() {
+        if (this.supportsTargetTypeCache !== null)
+            return this.supportsTargetTypeCache;
+        try {
+            if (this.db.provider === 'postgres') {
+                const row = this.db.prepare(`
+                    SELECT 1
+                    FROM information_schema.columns
+                    WHERE table_schema = current_schema()
+                      AND table_name = 'workspace_asset_links'
+                      AND column_name = 'target_type'
+                    LIMIT 1
+                `).get();
+                this.supportsTargetTypeCache = Boolean(row);
+                return this.supportsTargetTypeCache;
+            }
+            const columns = this.db.prepare(`PRAGMA table_info(workspace_asset_links)`).all();
+            this.supportsTargetTypeCache = columns.some((column) => String(column.name || '').trim() === 'target_type');
+            return this.supportsTargetTypeCache;
+        }
+        catch {
+            this.supportsTargetTypeCache = false;
+            return false;
+        }
+    }
     normalizePersistedAsset(entry) {
         const normalizedKind = normalizeCanonicalAssetKind({
             kind: entry.kind,
@@ -411,47 +441,93 @@ export class WorkspaceAssetStore {
     upsertLink(input) {
         const workspaceId = normalizeWorkspaceId(input.workspaceId);
         const assetId = normalizeId(input.assetId);
-        const taskId = normalizeId(input.taskId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
         const role = normalizeId(input.role, 'attachment');
         const createdAt = normalizeId(input.createdAt, new Date().toISOString());
         const updatedAt = normalizeId(input.updatedAt, createdAt);
-        this.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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            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 = excluded.deleted_at
-        `).run(this.tenantId, workspaceId, assetId, taskId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        if (!targetId) {
+            throw new Error('Workspace asset links require a targetId.');
+        }
+        if (this.supportsTargetType()) {
+            this.db.prepare(`
+                INSERT INTO workspace_asset_links (
+                    tenant_id,
+                    workspace_id,
+                    asset_id,
+                    target_type,
+                    task_id,
+                    role,
+                    display_name,
+                    sort_order,
+                    created_at,
+                    updated_at,
+                    deleted_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
+                    target_type = excluded.target_type,
+                    display_name = excluded.display_name,
+                    sort_order = excluded.sort_order,
+                    updated_at = excluded.updated_at,
+                    deleted_at = excluded.deleted_at
+            `).run(this.tenantId, workspaceId, assetId, targetType, targetId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        }
+        else {
+            this.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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                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 = excluded.deleted_at
+            `).run(this.tenantId, workspaceId, assetId, targetId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        }
         return this.listLinksForAsset(assetId, workspaceId, { includeDeleted: true })
-            .find((entry) => entry.taskId === taskId && entry.role === role);
+            .find((entry) => entry.targetType === targetType && entry.targetId === targetId && entry.role === role);
     }
     listLinksForTask(taskIdRaw, workspaceIdRaw, options) {
+        return this.listLinksForTarget('task', taskIdRaw, workspaceIdRaw, options);
+    }
+    listLinksForTarget(targetTypeRaw, targetIdRaw, workspaceIdRaw, options) {
         const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
-        const taskId = normalizeId(taskIdRaw);
-        if (!taskId)
+        const targetType = normalizeId(targetTypeRaw, 'task');
+        const targetId = normalizeId(targetIdRaw);
+        if (!targetId)
             return [];
         const includeDeleted = options?.includeDeleted === true;
-        const rows = this.db.prepare(`
-            SELECT *
-            FROM workspace_asset_links
-            WHERE tenant_id = ?
-              AND workspace_id = ?
-              AND task_id = ?
-              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
-            ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
-        `).all(this.tenantId, workspaceId, taskId);
+        const rows = this.supportsTargetType()
+            ? this.db.prepare(`
+                SELECT *
+                FROM workspace_asset_links
+                WHERE tenant_id = ?
+                  AND workspace_id = ?
+                  AND target_type = ?
+                  AND task_id = ?
+                  ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
+            `).all(this.tenantId, workspaceId, targetType, targetId)
+            : (targetType === 'task'
+                ? this.db.prepare(`
+                        SELECT *
+                        FROM workspace_asset_links
+                        WHERE tenant_id = ?
+                          AND workspace_id = ?
+                          AND task_id = ?
+                          ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+                        ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
+                    `).all(this.tenantId, workspaceId, targetId)
+                : []);
         return rows.map(mapLinkRow);
     }
     listLinksForAsset(assetIdRaw, workspaceIdRaw, options) {
@@ -474,23 +550,35 @@ export class WorkspaceAssetStore {
     deleteLink(input) {
         const workspaceId = normalizeWorkspaceId(input.workspaceId);
         const assetId = normalizeId(input.assetId);
-        const taskId = normalizeId(input.taskId);
+        const targetType = normalizeId(input.targetType, input.taskId ? 'task' : 'task');
+        const targetId = normalizeId(input.targetId, input.taskId || '');
         const role = normalizeId(input.role);
-        if (!assetId || !taskId || !role)
+        if (!assetId || !targetId || !role)
             return false;
         if (input.hardDelete) {
-            const result = this.db.prepare(`
-                DELETE FROM workspace_asset_links
-                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
-            `).run(this.tenantId, workspaceId, assetId, taskId, role);
+            const result = this.supportsTargetType()
+                ? this.db.prepare(`
+                    DELETE FROM workspace_asset_links
+                    WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND target_type = ? AND task_id = ? AND role = ?
+                `).run(this.tenantId, workspaceId, assetId, targetType, targetId, role)
+                : this.db.prepare(`
+                    DELETE FROM workspace_asset_links
+                    WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+                `).run(this.tenantId, workspaceId, assetId, targetId, role);
             return Number(result?.changes || 0) > 0;
         }
         const nowIso = new Date().toISOString();
-        const result = this.db.prepare(`
-            UPDATE workspace_asset_links
-            SET deleted_at = ?, updated_at = ?
-            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
-        `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, taskId, role);
+        const result = this.supportsTargetType()
+            ? this.db.prepare(`
+                UPDATE workspace_asset_links
+                SET deleted_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND target_type = ? AND task_id = ? AND role = ?
+            `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, targetType, targetId, role)
+            : this.db.prepare(`
+                UPDATE workspace_asset_links
+                SET deleted_at = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+            `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, targetId, role);
         return Number(result?.changes || 0) > 0;
     }
 }

package/dist/storage/workspaceAssetStore.test.js

@@ -23,6 +23,40 @@ function makeStore() {
         }
     };
 }
+function makeLegacyLinkStore() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-legacy-'));
+    const dbPath = path.join(root, 'taskforce.db');
+    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
+    ensureTaskAssetsSchema(db);
+    ensureWorkspaceAssetsSchema(db);
+    ensureDocumentReferenceSchema(db);
+    db.exec(`DROP TABLE IF EXISTS workspace_asset_links`);
+    db.exec(`
+        CREATE TABLE IF NOT EXISTS workspace_asset_links (
+            tenant_id TEXT NOT NULL DEFAULT 'default',
+            workspace_id TEXT NOT NULL,
+            asset_id TEXT NOT NULL,
+            task_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            display_name TEXT,
+            sort_order INTEGER,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            deleted_at TEXT,
+            PRIMARY KEY (tenant_id, workspace_id, asset_id, task_id, role)
+        );
+    `);
+    const store = new WorkspaceAssetStore(db, 'default');
+    return {
+        root,
+        db,
+        store,
+        cleanup() {
+            db.close();
+            fs.rmSync(root, { recursive: true, force: true });
+        }
+    };
+}
 describe('WorkspaceAssetStore', () => {
     const cleanups = [];
     afterEach(() => {
@@ -64,6 +98,50 @@ describe('WorkspaceAssetStore', () => {
             referenceNumber: 1
         });
     });
+    it('supports legacy workspace asset links without target_type', () => {
+        const ctx = makeLegacyLinkStore();
+        cleanups.push(() => ctx.cleanup());
+        const now = new Date().toISOString();
+        ctx.store.upsertAsset({
+            assetId: 'asset-legacy-1',
+            workspaceId: 'workspace-1',
+            kind: 'file',
+            originalFilename: 'legacy.pdf',
+            mimeType: 'application/pdf',
+            storageProvider: 'local',
+            storageKey: 'workspaces/workspace-1/assets/files/asset-legacy-1-legacy.pdf',
+            contentSha256: 'sha-legacy',
+            sizeBytes: 42,
+            createdAt: now,
+            updatedAt: now
+        });
+        const created = ctx.store.upsertLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-legacy-1',
+            taskId: 'task-1',
+            role: 'attachment',
+            displayName: 'Legacy attachment',
+            createdAt: now,
+            updatedAt: now
+        });
+        expect(created.targetType).toBe('task');
+        expect(created.targetId).toBe('task-1');
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([
+            expect.objectContaining({
+                assetId: 'asset-legacy-1',
+                targetType: 'task',
+                targetId: 'task-1',
+                role: 'attachment'
+            })
+        ]);
+        expect(ctx.store.deleteLink({
+            workspaceId: 'workspace-1',
+            assetId: 'asset-legacy-1',
+            taskId: 'task-1',
+            role: 'attachment'
+        })).toBe(true);
+        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([]);
+    });
     it('assigns sequential document reference numbers per workspace', () => {
         const ctx = makeStore();
         cleanups.push(() => ctx.cleanup());
@@ -382,7 +460,7 @@ describe('WorkspaceAssetStore', () => {
         const all = ctx.store.listByWorkspace('workspace-1', { includeDeleted: true });
         expect(all.map((entry) => entry.assetId).sort()).toEqual(['asset-a', 'asset-b']);
     });
-    it('creates, lists, and soft-deletes task links separately from asset identity', () => {
+    it('creates, lists, and soft-deletes generic target links while preserving task compatibility helpers', () => {
         const ctx = makeStore();
         cleanups.push(() => ctx.cleanup());
         ctx.store.upsertAsset({
@@ -399,27 +477,36 @@ describe('WorkspaceAssetStore', () => {
         ctx.store.upsertLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-1',
+            targetType: 'task',
+            targetId: 'task-1',
             role: 'attachment',
             sortOrder: 2
         });
         ctx.store.upsertLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-2',
+            targetType: 'initiative',
+            targetId: 'initiative-2',
             role: 'reference',
             sortOrder: 1
         });
         const taskLinks = ctx.store.listLinksForTask('task-1', 'workspace-1');
         expect(taskLinks).toHaveLength(1);
-        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment' });
+        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment', targetType: 'task', targetId: 'task-1', taskId: 'task-1' });
+        const initiativeLinks = ctx.store.listLinksForTarget('initiative', 'initiative-2', 'workspace-1');
+        expect(initiativeLinks).toHaveLength(1);
+        expect(initiativeLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'reference', targetType: 'initiative', targetId: 'initiative-2', taskId: null });
         const assetLinks = ctx.store.listLinksForAsset('asset-link-1', 'workspace-1');
         expect(assetLinks).toHaveLength(2);
-        expect(assetLinks.map((entry) => entry.taskId)).toEqual(['task-2', 'task-1']);
+        expect(assetLinks.map((entry) => [entry.targetType, entry.targetId])).toEqual([
+            ['initiative', 'initiative-2'],
+            ['task', 'task-1'],
+        ]);
         expect(ctx.store.deleteLink({
             workspaceId: 'workspace-1',
             assetId: 'asset-link-1',
-            taskId: 'task-1',
+            targetType: 'task',
+            targetId: 'task-1',
             role: 'attachment'
         })).toBe(true);
         expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toHaveLength(0);