@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/migrations/taskUpdatedAtSyncDriftMigration.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+import { serializeTaskRootForSync } from '../sync/v3/workspaceSyncV3TaskRootProjection.js';
+type TaskSource = Parameters<typeof serializeTaskRootForSync>[0];
+export interface TaskUpdatedAtSyncDriftRepairResult {
+    repairedTasks: number;
+    semanticDriftTasks: number;
+}
+/**
+ * Repairs the narrow watermark drift created when a legacy assignee alias was
+ * physically canonicalized after its sync payload was already canonical. Any
+ * difference beyond updatedAt remains untouched so reconciliation still fails
+ * closed for an unjournaled semantic mutation.
+ */
+export declare function repairTaskUpdatedAtOnlySyncDrift(input: {
+    db: DatabaseAdapter;
+    tenantId: string;
+    loadTask: (taskId: string, workspaceId: string) => TaskSource | null;
+    now?: string;
+}): TaskUpdatedAtSyncDriftRepairResult;
+export {};

package/dist/migrations/taskUpdatedAtSyncDriftMigration.js

@@ -0,0 +1,153 @@
+import { canonicalWorkspaceSyncJson } from '../sync/v3/canonicalWorkspaceSyncJson.js';
+import { projectWorkspaceSyncV3TaskRootJournalRow, serializeTaskRootForSync, } from '../sync/v3/workspaceSyncV3TaskRootProjection.js';
+const MIGRATION_KEY = 'migration.task_updated_at_representation_drift.v1';
+const FULL_TASK_MUTATIONS = [
+    'create',
+    'metadata-update',
+    'archive',
+    'unarchive',
+    'complete',
+    'reopen',
+    'set-status',
+];
+function journalRow(row) {
+    return {
+        sequence: String(row.sequence),
+        contractVersion: Number(row.contract_version),
+        operationId: String(row.operation_id || ''),
+        clientId: String(row.client_id || ''),
+        domain: String(row.domain || ''),
+        entityId: String(row.entity_id || ''),
+        mutationKind: String(row.mutation_kind || ''),
+        entityRevision: String(row.entity_revision),
+        lifecycleRevision: String(row.lifecycle_revision),
+        contentSha256: row.content_sha256 == null ? null : String(row.content_sha256),
+        sizeBytes: row.size_bytes == null ? null : String(row.size_bytes),
+        payloadJson: String(row.payload_json || ''),
+        occurredAt: String(row.occurred_at || ''),
+    };
+}
+function withoutUpdatedAt(payload) {
+    const { updatedAt: _updatedAt, ...rest } = payload;
+    return rest;
+}
+/**
+ * Repairs the narrow watermark drift created when a legacy assignee alias was
+ * physically canonicalized after its sync payload was already canonical. Any
+ * difference beyond updatedAt remains untouched so reconciliation still fails
+ * closed for an unjournaled semantic mutation.
+ */
+export function repairTaskUpdatedAtOnlySyncDrift(input) {
+    const tenantId = String(input.tenantId || '').trim();
+    if (!tenantId)
+        throw new Error('Task updatedAt drift repair requires a tenant id.');
+    const existingMarker = input.db.prepare(`
+        SELECT 1 AS present FROM system_settings
+        WHERE tenant_id = ? AND settings_key = ?
+        LIMIT 1
+    `).get(tenantId, MIGRATION_KEY);
+    const placeholders = FULL_TASK_MUTATIONS.map(() => '?').join(', ');
+    const candidates = input.db.prepare(`
+        SELECT journal.*, task.updated_at AS current_updated_at
+        FROM workspace_sync_entity_revisions AS revision
+        JOIN workspace_sync_journal AS journal
+          ON journal.tenant_id = revision.tenant_id
+         AND journal.workspace_id = revision.workspace_id
+         AND journal.domain = revision.domain
+         AND journal.entity_id = revision.entity_id
+         AND journal.sequence = revision.last_sequence
+        JOIN tasks AS task
+          ON task.tenant_id = revision.tenant_id
+         AND task.workspace_id = revision.workspace_id
+         AND task.id = revision.entity_id
+        WHERE revision.tenant_id = ?
+          AND revision.domain = 'task'
+          AND journal.mutation_kind IN (${placeholders})
+        ORDER BY revision.workspace_id, revision.entity_id
+    `).all(tenantId, ...FULL_TASK_MUTATIONS);
+    let repairedTasks = 0;
+    let semanticDriftTasks = 0;
+    const run = input.db.transaction(() => {
+        for (const candidate of candidates) {
+            const workspaceId = String(candidate.workspace_id || '').trim();
+            const taskId = String(candidate.entity_id || '').trim();
+            const currentUpdatedAt = String(candidate.current_updated_at || '').trim();
+            let rawPayload;
+            try {
+                const parsed = JSON.parse(String(candidate.payload_json || ''));
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                    continue;
+                rawPayload = parsed;
+            }
+            catch {
+                continue;
+            }
+            const durableUpdatedAt = String(rawPayload.updatedAt || '').trim();
+            if (!workspaceId || !taskId || !currentUpdatedAt || !durableUpdatedAt
+                || currentUpdatedAt === durableUpdatedAt)
+                continue;
+            const task = input.loadTask(taskId, workspaceId);
+            if (!task)
+                throw new Error(`Task updatedAt drift repair cannot load task: ${taskId}.`);
+            const canonicalPayload = serializeTaskRootForSync(task);
+            const projected = projectWorkspaceSyncV3TaskRootJournalRow(journalRow(candidate));
+            if (!projected || !projected.payload || typeof projected.payload !== 'object'
+                || Array.isArray(projected.payload)) {
+                throw new Error(`Task updatedAt drift repair cannot project task: ${taskId}.`);
+            }
+            const durablePayload = projected.payload;
+            if (canonicalWorkspaceSyncJson(withoutUpdatedAt(canonicalPayload))
+                !== canonicalWorkspaceSyncJson(withoutUpdatedAt(durablePayload))) {
+                semanticDriftTasks += 1;
+                continue;
+            }
+            const result = input.db.prepare(`
+                UPDATE tasks
+                SET updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND id = ? AND updated_at = ?
+                  AND EXISTS (
+                      SELECT 1 FROM workspace_sync_entity_revisions
+                      WHERE tenant_id = ? AND workspace_id = ? AND domain = 'task'
+                        AND entity_id = ? AND last_sequence = ?
+                  )
+            `).run(durableUpdatedAt, tenantId, workspaceId, taskId, currentUpdatedAt, tenantId, workspaceId, taskId, String(candidate.sequence));
+            if (result.changes !== 1) {
+                const current = input.db.prepare(`
+                    SELECT task.updated_at, CAST(revision.last_sequence AS TEXT) AS last_sequence
+                    FROM tasks AS task
+                    JOIN workspace_sync_entity_revisions AS revision
+                      ON revision.tenant_id = task.tenant_id
+                     AND revision.workspace_id = task.workspace_id
+                     AND revision.domain = 'task'
+                     AND revision.entity_id = task.id
+                    WHERE task.tenant_id = ? AND task.workspace_id = ? AND task.id = ?
+                `).get(tenantId, workspaceId, taskId);
+                if (String(current?.last_sequence ?? '') !== String(candidate.sequence))
+                    continue;
+                if (String(current?.updated_at || '') === durableUpdatedAt) {
+                    const currentTask = input.loadTask(taskId, workspaceId);
+                    if (!currentTask)
+                        throw new Error(`Task updatedAt drift repair cannot reload task: ${taskId}.`);
+                    const currentPayload = serializeTaskRootForSync(currentTask);
+                    if (canonicalWorkspaceSyncJson(withoutUpdatedAt(currentPayload))
+                        === canonicalWorkspaceSyncJson(withoutUpdatedAt(durablePayload)))
+                        continue;
+                }
+                throw new Error(`Task changed during updatedAt drift repair: ${taskId}.`);
+            }
+            repairedTasks += 1;
+        }
+        if (!existingMarker || repairedTasks > 0) {
+            const completedAt = input.now || new Date().toISOString();
+            input.db.prepare(`
+                INSERT INTO system_settings (tenant_id, settings_key, payload, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT (tenant_id, settings_key) DO UPDATE SET
+                    payload = excluded.payload,
+                    updated_at = excluded.updated_at
+            `).run(tenantId, MIGRATION_KEY, JSON.stringify({ completedAt, repairedTasks, semanticDriftTasks }), completedAt);
+        }
+    });
+    run();
+    return { repairedTasks, semanticDriftTasks };
+}

package/dist/migrations/taskforceAgentDefinitionMigration.d.ts

@@ -0,0 +1,26 @@
+import type { DatabaseAdapter } from '../storage/databaseAdapter.js';
+import { type AgentConfigurationIssue, type AgentConfigurationState, type AgentDefinitionV1, type AgentLifecycleStatus } from '../shared/taskforceAgentDefinition.js';
+export declare const LEGACY_AGENT_PURPOSE = "Help users complete work in Taskforce.";
+export declare const LEGACY_AGENT_TOOL_POLICY_ID = "managed-agent-default";
+export interface LegacyTaskforceAgentDefinitionInput {
+    name: unknown;
+    providerKey: unknown;
+    modelKey: unknown;
+    modelTier: unknown;
+    systemPrompt: unknown;
+    enabled?: unknown;
+    deletedAt?: unknown;
+}
+export interface LegacyTaskforceAgentDefinitionMigration {
+    definition: AgentDefinitionV1 | null;
+    definitionValue: unknown;
+    definitionJson: string;
+    definitionHash: string;
+    definitionRevision: number;
+    lifecycleStatus: AgentLifecycleStatus;
+    configurationState: AgentConfigurationState;
+    configurationIssues: AgentConfigurationIssue[];
+}
+export declare function sha256CanonicalJson(value: unknown): string;
+export declare function migrateLegacyTaskforceAgentDefinition(input: LegacyTaskforceAgentDefinitionInput): LegacyTaskforceAgentDefinitionMigration;
+export declare function backfillLegacyTaskforceAgentDefinitions(db: DatabaseAdapter): number;

package/dist/migrations/taskforceAgentDefinitionMigration.js

@@ -0,0 +1,116 @@
+import { createHash } from 'node:crypto';
+import { inspectAgentDefinition, serializeCanonicalJson, } from '../shared/taskforceAgentDefinition.js';
+export const LEGACY_AGENT_PURPOSE = 'Help users complete work in Taskforce.';
+export const LEGACY_AGENT_TOOL_POLICY_ID = 'managed-agent-default';
+function legacyString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function lifecycleFromLegacy(input) {
+    if (legacyString(input.deletedAt))
+        return 'retired';
+    return input.enabled === false || input.enabled === 0 ? 'disabled' : 'active';
+}
+export function sha256CanonicalJson(value) {
+    return createHash('sha256').update(serializeCanonicalJson(value)).digest('hex');
+}
+export function migrateLegacyTaskforceAgentDefinition(input) {
+    const name = legacyString(input.name);
+    const providerKey = legacyString(input.providerKey);
+    const modelKey = legacyString(input.modelKey);
+    const modelTier = legacyString(input.modelTier);
+    const systemPrompt = typeof input.systemPrompt === 'string' ? input.systemPrompt.trim() : '';
+    const candidate = {
+        schemaVersion: 1,
+        name,
+        purpose: LEGACY_AGENT_PURPOSE,
+        model: {
+            providerKey,
+            modelKey,
+            tier: modelTier,
+        },
+        behavior: {
+            ...(systemPrompt ? { workingGuidelines: systemPrompt } : {}),
+        },
+        presentation: {
+            avatar: {},
+        },
+        skillRefs: [],
+        toolPolicy: {
+            basePolicyRef: {
+                id: LEGACY_AGENT_TOOL_POLICY_ID,
+                resolution: 'current',
+            },
+        },
+    };
+    const inspected = inspectAgentDefinition(candidate);
+    const migrationIssue = {
+        code: 'legacy_purpose_defaulted',
+        path: 'purpose',
+        message: 'Purpose was absent from the legacy record and received the documented migration default.',
+    };
+    const definitionValue = inspected.definition || candidate;
+    const configurationIssues = [
+        migrationIssue,
+        ...inspected.issues,
+    ];
+    return {
+        definition: inspected.definition,
+        definitionValue,
+        definitionJson: serializeCanonicalJson(definitionValue),
+        definitionHash: sha256CanonicalJson(definitionValue),
+        definitionRevision: 1,
+        lifecycleStatus: lifecycleFromLegacy(input),
+        configurationState: inspected.definition ? 'valid' : 'needs-migration',
+        configurationIssues,
+    };
+}
+export function backfillLegacyTaskforceAgentDefinitions(db) {
+    // COMPAT_TRACK: taskforce-agent-definition-v1-legacy-flat-records
+    // COMPAT_REMOVE_AFTER: v0.4.0
+    const rows = db.prepare(`
+        SELECT
+            id,
+            name,
+            provider_key,
+            model_key,
+            model_tier,
+            system_prompt,
+            enabled,
+            deleted_at
+        FROM taskforce_agents
+        WHERE definition_json IS NULL OR TRIM(definition_json) = ''
+        ORDER BY id ASC
+    `).all();
+    if (rows.length === 0)
+        return 0;
+    const update = db.prepare(`
+        UPDATE taskforce_agents
+        SET lifecycle_status = ?,
+            definition_json = ?,
+            definition_revision = ?,
+            definition_hash = ?,
+            configuration_state = ?,
+            configuration_issues_json = ?
+        WHERE id = ?
+          AND (definition_json IS NULL OR TRIM(definition_json) = '')
+    `);
+    const apply = db.transaction(() => {
+        let migrated = 0;
+        for (const row of rows) {
+            const result = migrateLegacyTaskforceAgentDefinition({
+                name: row.name,
+                providerKey: row.provider_key,
+                modelKey: row.model_key,
+                modelTier: row.model_tier,
+                systemPrompt: row.system_prompt,
+                enabled: Number(row.enabled) !== 0,
+                deletedAt: row.deleted_at,
+            });
+            const write = update.run(result.lifecycleStatus, result.definitionJson, result.definitionRevision, result.definitionHash, result.configurationState, JSON.stringify(result.configurationIssues), String(row.id || ''));
+            if (Number(write.changes || 0) > 0)
+                migrated += 1;
+        }
+        return migrated;
+    });
+    return apply();
+}

package/dist/plugins/vite.js

@@ -9,8 +9,10 @@ import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { TaskforceCore } from '../core/Taskforce.js';
 import { createRoutes, matchRoute } from '../server/routes.js';
+import { formatApiErrorResponse } from '../server/routes/primitives.js';
 import { resolveDatabaseConfigFromEnv } from '../storage/providerConfig.js';
 import { resolveObjectStorageConfigFromEnv } from '../storage/objectStorageConfig.js';
+import { acquireLocalServiceOwnershipForRuntime } from '../server/localServiceOwnershipBootstrap.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // @ts-ignore
@@ -42,18 +44,9 @@ export function taskforcePlugin(options) {
     if (fs.existsSync(projectRoot)) {
         projectRoot = fs.realpathSync(projectRoot);
     }
-    const db = resolveDatabaseConfigFromEnv();
-    // Initialize Core
-    const core = new TaskforceCore({
-        projectRoot,
-        storagePath: options?.outputPath,
-        tenantId: process.env.TASKFORCE_TENANT_ID || 'default',
-        database: {
-            provider: db.provider,
-            connectionString: db.connectionString
-        }
-    });
-    const { basePath } = core.getPaths();
+    let core;
+    let basePath = '';
+    let ownership = null;
     return {
         name: 'taskforce',
         handleHotUpdate({ file, server }) {
@@ -66,7 +59,47 @@ export function taskforcePlugin(options) {
                 return []; // Return empty array to stop HMR propagation/reload
             }
         },
-        configureServer(server) {
+        async configureServer(server) {
+            const db = resolveDatabaseConfigFromEnv();
+            const storageBasePath = options?.outputPath
+                ? (path.isAbsolute(options.outputPath) ? options.outputPath : path.resolve(projectRoot, options.outputPath))
+                : path.resolve(projectRoot, '.taskforce');
+            ownership = await acquireLocalServiceOwnershipForRuntime(projectRoot, process.env, db.provider === 'sqlite'
+                ? {
+                    databaseIdentity: path.resolve(storageBasePath, 'taskforce.db'),
+                    databaseIdentityKind: 'path',
+                }
+                : {}) || null;
+            if (!ownership?.owned || !ownership.localDataOwnerPermit) {
+                throw new Error('The Taskforce Vite plugin could not acquire exclusive local data ownership. '
+                    + 'Stop the shared Taskforce service before starting this legacy plugin runtime.');
+            }
+            try {
+                core = new TaskforceCore({
+                    projectRoot,
+                    storagePath: options?.outputPath,
+                    tenantId: process.env.TASKFORCE_TENANT_ID || 'default',
+                    localDataOwnerPermit: ownership.localDataOwnerPermit,
+                    database: {
+                        provider: db.provider,
+                        connectionString: db.connectionString
+                    }
+                });
+                ({ basePath } = core.getPaths());
+            }
+            catch (error) {
+                await ownership.release();
+                ownership = null;
+                throw error;
+            }
+            server.httpServer?.once('close', () => {
+                try {
+                    core.close();
+                }
+                finally {
+                    void ownership?.release();
+                }
+            });
             // Hot Module Replacement for Taskforce data
             // Listen for changes in the storage directory and notify client
             server.watcher.add(basePath);
@@ -260,11 +293,9 @@ export function taskforcePlugin(options) {
                         console.error('[Taskforce] API error:', error);
                         // Only send error response if headers haven't been sent
                         if (!res.headersSent) {
-                            const statusCode = Number.isFinite(Number(error?.statusCode))
-                                ? Math.max(400, Math.min(599, Number(error.statusCode)))
-                                : 500;
+                            const { statusCode, body } = formatApiErrorResponse(error);
                             res.writeHead(statusCode, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: error.message }));
+                            res.end(JSON.stringify(body));
                         }
                     }
                     return;

package/dist/runtime/appGateDefinitions.d.ts

@@ -11,22 +11,28 @@ export declare const APP_GATE_DEFINITIONS: {
         readonly owner: "taskforce";
         readonly removalMilestone: "Document Manager GA";
     };
-    readonly 'workflows.workspace_access': {
+    readonly 'workflow_manager.workspace_access': {
         readonly enabled: false;
-        readonly description: "Workflow workspace readiness gate.";
+        readonly description: "Workflow Manager workspace readiness gate.";
         readonly owner: "taskforce";
-        readonly removalMilestone: "Workflow workspace GA";
+        readonly removalMilestone: "Workflow Manager GA";
     };
-    readonly 'agents.workspace_access': {
-        readonly enabled: true;
-        readonly description: "Agents workspace readiness gate.";
+    readonly 'taskforce_agents.workspace_access': {
+        readonly enabled: false;
+        readonly description: "Taskforce Agents workspace readiness gate.";
         readonly owner: "taskforce";
-        readonly removalMilestone: "Agents workspace GA";
+        readonly removalMilestone: "Taskforce Agents workspace GA";
     };
-    readonly 'initiatives.workspace_access': {
+    readonly 'ai_profiles.workspace_access': {
         readonly enabled: true;
-        readonly description: "Initiatives workspace readiness gate.";
+        readonly description: "AI Profiles workspace readiness gate.";
+        readonly owner: "taskforce";
+        readonly removalMilestone: "AI Profiles workspace GA";
+    };
+    readonly 'planning.workspace_access': {
+        readonly enabled: false;
+        readonly description: "Planning workspace readiness gate.";
         readonly owner: "taskforce";
-        readonly removalMilestone: "Initiatives workspace GA";
+        readonly removalMilestone: "Planning workspace GA";
     };
 };

package/dist/runtime/appGateDefinitions.js

@@ -11,22 +11,28 @@ export const APP_GATE_DEFINITIONS = {
         owner: 'taskforce',
         removalMilestone: 'Document Manager GA'
     },
-    'workflows.workspace_access': {
+    'workflow_manager.workspace_access': {
         enabled: false,
-        description: 'Workflow workspace readiness gate.',
+        description: 'Workflow Manager workspace readiness gate.',
         owner: 'taskforce',
-        removalMilestone: 'Workflow workspace GA'
+        removalMilestone: 'Workflow Manager GA'
     },
-    'agents.workspace_access': {
-        enabled: true,
-        description: 'Agents workspace readiness gate.',
+    'taskforce_agents.workspace_access': {
+        enabled: false,
+        description: 'Taskforce Agents workspace readiness gate.',
         owner: 'taskforce',
-        removalMilestone: 'Agents workspace GA'
+        removalMilestone: 'Taskforce Agents workspace GA'
     },
-    'initiatives.workspace_access': {
+    'ai_profiles.workspace_access': {
         enabled: true,
-        description: 'Initiatives workspace readiness gate.',
+        description: 'AI Profiles workspace readiness gate.',
+        owner: 'taskforce',
+        removalMilestone: 'AI Profiles workspace GA'
+    },
+    'planning.workspace_access': {
+        enabled: false,
+        description: 'Planning workspace readiness gate.',
         owner: 'taskforce',
-        removalMilestone: 'Initiatives workspace GA'
+        removalMilestone: 'Planning workspace GA'
     }
 };

package/dist/runtime/appGates.d.ts

@@ -1,10 +1,11 @@
 export type RuntimeMode = 'local' | 'cloud';
 export declare const ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY: "annotated_attachments.workspace_access";
 export declare const DOCUMENT_WORKSPACE_FEATURE_KEY: "documents.workspace_access";
-export declare const WORKFLOWS_WORKSPACE_FEATURE_KEY: "workflows.workspace_access";
-export declare const AGENTS_WORKSPACE_FEATURE_KEY: "agents.workspace_access";
-export declare const INITIATIVES_WORKSPACE_FEATURE_KEY: "initiatives.workspace_access";
-export type AppGateKey = typeof ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY | typeof DOCUMENT_WORKSPACE_FEATURE_KEY | typeof WORKFLOWS_WORKSPACE_FEATURE_KEY | typeof AGENTS_WORKSPACE_FEATURE_KEY | typeof INITIATIVES_WORKSPACE_FEATURE_KEY;
+export declare const WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY: "workflow_manager.workspace_access";
+export declare const TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY: "taskforce_agents.workspace_access";
+export declare const AI_PROFILES_WORKSPACE_FEATURE_KEY: "ai_profiles.workspace_access";
+export declare const PLANNING_WORKSPACE_FEATURE_KEY: "planning.workspace_access";
+export type AppGateKey = typeof ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY | typeof DOCUMENT_WORKSPACE_FEATURE_KEY | typeof WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY | typeof TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY | typeof AI_PROFILES_WORKSPACE_FEATURE_KEY | typeof PLANNING_WORKSPACE_FEATURE_KEY;
 export interface AppGateDefinition {
     key: AppGateKey;
     enabled: boolean;

package/dist/runtime/appGates.js

@@ -1,9 +1,10 @@
 import { APP_GATE_DEFINITIONS as APP_GATE_CONFIG } from './appGateDefinitions.js';
 export const ANNOTATED_ATTACHMENTS_WORKSPACE_FEATURE_KEY = 'annotated_attachments.workspace_access';
 export const DOCUMENT_WORKSPACE_FEATURE_KEY = 'documents.workspace_access';
-export const WORKFLOWS_WORKSPACE_FEATURE_KEY = 'workflows.workspace_access';
-export const AGENTS_WORKSPACE_FEATURE_KEY = 'agents.workspace_access';
-export const INITIATIVES_WORKSPACE_FEATURE_KEY = 'initiatives.workspace_access';
+export const WORKFLOW_MANAGER_WORKSPACE_FEATURE_KEY = 'workflow_manager.workspace_access';
+export const TASKFORCE_AGENTS_WORKSPACE_FEATURE_KEY = 'taskforce_agents.workspace_access';
+export const AI_PROFILES_WORKSPACE_FEATURE_KEY = 'ai_profiles.workspace_access';
+export const PLANNING_WORKSPACE_FEATURE_KEY = 'planning.workspace_access';
 export const APP_GATE_DEFINITIONS = Object.entries(APP_GATE_CONFIG).reduce((acc, [key, definition]) => {
     acc[key] = {
         key: key,

package/dist/server/aiProfileAvatarAssets.d.ts

@@ -1,7 +1,7 @@
 import type { TaskforceCore } from '../core/Taskforce.js';
 import type { ObjectStorageClient } from '../storage/objectStorageClient.js';
 import type { WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
-type AiAvatarSlot = 'display' | 'source';
+export { buildAiProfileAvatarStorageKey } from '../utils/aiProfileAvatarPaths.js';
 export interface AiProfileAvatarPayload {
     buffer: Buffer;
     mimeType: string;
@@ -24,14 +24,18 @@ export interface SaveAiProfileAvatarInput {
     profileId: string;
     display: AiProfileAvatarPayload;
     source?: AiProfileAvatarPayload | null;
+    preserveExistingSource?: boolean;
     actorId?: string | null;
+    expectedProfileState?: {
+        avatarRevision: number;
+        avatarUrl?: string | null;
+        avatarSourceUrl?: string | null;
+        requireGenerationEligibility?: boolean;
+    };
+}
+export declare class AiProfileAvatarStateConflictError extends Error {
+    constructor();
 }
-export declare function buildAiProfileAvatarStorageKey(input: {
-    workspaceId: string;
-    profileId: string;
-    slot: AiAvatarSlot;
-    mimeType: string;
-}): string;
 export declare function storageKeyFromContextUrl(url: unknown): string | null;
 export declare function saveAiProfileAvatarAssets(deps: AiProfileAvatarAssetDeps, input: SaveAiProfileAvatarInput): Promise<{
     profile: import("../core/Taskforce.js").AiProfileRecord;
@@ -46,4 +50,3 @@ export declare function clearAiProfileAvatarAssets(deps: AiProfileAvatarAssetDep
 }): Promise<{
     profile: import("../core/Taskforce.js").AiProfileRecord;
 }>;
-export {};