@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/config/envSchema.js

@@ -11,6 +11,7 @@ const SPECS = [
     { key: 'TASKFORCE_DB_PROVIDER', description: 'Database provider (sqlite|postgres).', category: 'Core', defaultValue: 'sqlite', example: 'postgres', targets: ['server', 'all'] },
     { key: 'TASKFORCE_BILLING_ENABLED', description: 'Enable Stripe billing routes and webhook processing.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_DATABASE_URL', description: 'Postgres connection string when provider=postgres.', category: 'Core', example: 'postgresql://user:pass@host:5432/db', secret: true, targets: ['server', 'all'] },
+    { key: 'TASKFORCE_CLOUD_READ_WORKERS', description: 'Bounded cloud collection-read worker count (1-8, or 0 to disable).', category: 'Core', defaultValue: '2', targets: ['server', 'all'] },
     { key: 'TASKFORCE_ALLOW_SQLITE_IN_CLOUD', description: 'Emergency override to allow sqlite in cloud runtime.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_FORCE_SETUP', description: 'Force local setup gate for development.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_FORCE_GLOBAL_SETUP', description: 'Force global setup step for development.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
@@ -142,10 +143,15 @@ const SPECS = [
     { key: 'TASKFORCE_BEDROCK_SMOKE_MAX_TOKENS', description: 'Maximum output tokens for live Bedrock smoke tests.', category: 'AI', defaultValue: '128', targets: ['server', 'all'] },
     { key: 'TASKFORCE_BEDROCK_MANTLE_MODEL_KEY', description: 'Optional model key for Bedrock Mantle smoke tests (openai.gpt-5-4|xai.grok-4-3).', category: 'AI', defaultValue: 'openai.gpt-5-4', targets: ['server', 'all'] },
     { key: 'TASKFORCE_BEDROCK_ENV_FILE', description: 'Optional env file path for the Bedrock smoke script.', category: 'AI', defaultValue: '.env.local', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS', description: 'Enable internal local-development-only Taskforce Agent subscription-auth model adapters such as OpenAI Codex app-server.', category: 'AI', defaultValue: 'false', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_CODEX_APP_SERVER_COMMAND', description: 'Optional Codex CLI command path for the internal OpenAI Codex app-server Taskforce Agent adapter.', category: 'AI', defaultValue: 'codex', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_CODEX_APP_SERVER_CWD', description: 'Optional working directory for the internal Codex app-server subprocess. Defaults to the system temp directory.', category: 'AI', targets: ['server', 'all'] },
     { key: 'TASKFORCE_ALLOWED_ORIGINS', description: 'Allowed CORS origins (comma-separated).', category: 'Security', targets: ['server', 'all'] },
     { key: 'TASKFORCE_API_RATE_LIMIT_ENABLED', description: 'Enable API rate limiter.', category: 'Security', defaultValue: 'true', targets: ['server', 'all'] },
     { key: 'TASKFORCE_API_RATE_LIMIT_MAX_REQUESTS', description: 'API rate limit max requests per window.', category: 'Security', defaultValue: '120', targets: ['server', 'all'] },
     { key: 'TASKFORCE_API_RATE_LIMIT_WINDOW_MS', description: 'API rate limit window size in ms.', category: 'Security', defaultValue: '60000', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_SYNC_FEED_RATE_LIMIT_MAX_REQUESTS', description: 'Workspace sync feed read limit per window.', category: 'Security', defaultValue: '600', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_SYNC_FEED_RATE_LIMIT_WINDOW_MS', description: 'Workspace sync feed read limit window size in ms.', category: 'Security', defaultValue: '60000', targets: ['server', 'all'] },
     { key: 'TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_MAX_REQUESTS', description: 'Stripe webhook-specific rate limit max requests per window.', category: 'Security', defaultValue: '600', targets: ['server', 'all'] },
     { key: 'TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_WINDOW_MS', description: 'Stripe webhook-specific rate limit window size in ms.', category: 'Security', defaultValue: '60000', targets: ['server', 'all'] },
     { key: 'TASKFORCE_MAX_PAYLOAD_BYTES', description: 'Maximum accepted API payload size in bytes.', category: 'Security', defaultValue: '1048576', targets: ['server', 'all'] },
@@ -167,6 +173,8 @@ const SPECS = [
     { key: 'TASKFORCE_BUILD_DEPLOY_ID', description: 'Build deploy ID metadata.', category: 'Build', targets: ['server', 'all'] },
     { key: 'TASKFORCE_UI_DIST_DIR', description: 'Override the standalone UI distribution directory for isolated local QA runtimes.', category: 'Build', targets: ['server', 'all'] },
     { key: 'TASKFORCE_REQUIRE_EXACT_PORT', description: 'Require the standalone server to use only its requested port.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_QA_EXPECTED_WORKSPACE_ID', description: 'Require isolated cloud QA to resolve the exact expected workspace ID before mutation.', category: 'Core', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_QA_EXPECTED_WORKSPACE_SLUG', description: 'Require isolated cloud QA to resolve the expected workspace slug before mutation.', category: 'Core', targets: ['server', 'all'] },
     { key: 'DEBUG_MODE', description: 'Expose debug-only client diagnostics such as pricing source metadata.', category: 'Build', defaultValue: 'false', targets: ['all'] },
     { key: 'VITE_TASKFORCE_BASE_URL', description: 'Client base URL for both API and cloud auth when specific overrides are not set.', category: 'Client', example: 'https://performance-app.taskforcehq.ai', targets: ['all'] },
     { key: 'VITE_TASKFORCE_API_BASE_URL', description: 'Client API base URL (overrides VITE_TASKFORCE_BASE_URL when set).', category: 'Client', example: 'https://performance-app.taskforcehq.ai', targets: ['all'] },
@@ -184,17 +192,20 @@ const SPECS = [
     { key: 'SYNC_SOAK_PROFILE', description: 'Soak profile (smoke|stress|overnight).', category: 'Soak', defaultValue: 'smoke', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_DURATION_MIN', description: 'Soak duration in minutes.', category: 'Soak', defaultValue: '60', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_SEED', description: 'Deterministic soak seed.', category: 'Soak', example: '4242', targets: ['soak', 'all'] },
+    { key: 'SYNC_SOAK_TASK_ID_NAMESPACE', description: 'Optional per-run namespace for deterministic generated soak task IDs.', category: 'Soak', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_ARTIFACT_DIR', description: 'Soak artifacts output directory.', category: 'Soak', defaultValue: '.taskforce/soak-artifacts', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_ENABLE_SYNC_DEBUG', description: 'Enable sync debug diagnostics during soak.', category: 'Soak', defaultValue: 'false', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_STRESS_ACTIONS', description: 'Stress action count.', category: 'Soak', defaultValue: '150', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_STRESS_CHECKPOINT_INTERVAL', description: 'Stress checkpoint interval.', category: 'Soak', defaultValue: '50', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_STRESS_SETTLE_RETRIES', description: 'Stress settle retry count.', category: 'Soak', defaultValue: '3', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_STRESS_SETTLE_WAIT_MS', description: 'Stress settle wait time in ms.', category: 'Soak', defaultValue: '500', targets: ['soak', 'all'] },
+    { key: 'SYNC_SOAK_STRESS_BOOTSTRAP_PUSH_SETTLE', description: 'Enable legacy bootstrap-push checkpoint settlement in stress and overnight profiles.', category: 'Soak', defaultValue: 'true', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_STRESS_HARD_RESET_SETTLE', description: 'Enable hard reset settle path in stress.', category: 'Soak', defaultValue: 'true', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_OVERNIGHT_ACTION_INTERVAL_MS', description: 'Overnight action pacing interval in ms.', category: 'Soak', defaultValue: '60000', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_OVERNIGHT_CHECKPOINT_MIN', description: 'Overnight checkpoint interval in minutes.', category: 'Soak', defaultValue: '15', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_OVERNIGHT_MAX_ACTIONS', description: 'Overnight hard cap on action count.', category: 'Soak', defaultValue: '10000', targets: ['soak', 'all'] },
     { key: 'SYNC_SOAK_OVERNIGHT_MIN_ACTIONS', description: 'Overnight minimum actions expected before pass.', category: 'Soak', defaultValue: '80', targets: ['soak', 'all'] },
+    { key: 'SYNC_SOAK_OVERNIGHT_CLEAN_BASELINE_EVERY_ACTION', description: 'Require coordinator settlement before each accelerated overnight action.', category: 'Soak', defaultValue: 'false', targets: ['soak', 'all'] },
     { key: 'CF_ACCESS_CLIENT_ID', description: 'Cloudflare Access service token client id (soak).', category: 'Cloudflare', secret: true, targets: ['soak', 'all'] },
     { key: 'CF_ACCESS_CLIENT_SECRET', description: 'Cloudflare Access service token client secret (soak).', category: 'Cloudflare', secret: true, targets: ['soak', 'all'] }
 ];
@@ -254,6 +265,8 @@ function validateCommonNumbers(env, errors) {
         'PORT',
         'TASKFORCE_API_RATE_LIMIT_MAX_REQUESTS',
         'TASKFORCE_API_RATE_LIMIT_WINDOW_MS',
+        'TASKFORCE_SYNC_FEED_RATE_LIMIT_MAX_REQUESTS',
+        'TASKFORCE_SYNC_FEED_RATE_LIMIT_WINDOW_MS',
         'TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_MAX_REQUESTS',
         'TASKFORCE_STRIPE_WEBHOOK_RATE_LIMIT_WINDOW_MS',
         'TASKFORCE_MAX_PAYLOAD_BYTES',

package/dist/config/localServiceCloudTarget.d.ts

@@ -0,0 +1,10 @@
+import { type TaskforceCloudEnvironment } from './cloudEnvironment.js';
+export interface LocalServiceCloudTarget {
+    environment: TaskforceCloudEnvironment | null;
+    cloudProxyBaseUrl: string;
+    cloudAuthBaseUrl: string;
+}
+export declare function resolveLocalServiceCloudTarget(env: NodeJS.ProcessEnv): LocalServiceCloudTarget;
+export declare function applyLocalServiceCloudTarget(env: NodeJS.ProcessEnv, target: LocalServiceCloudTarget): void;
+export declare function parseLocalServiceCloudTarget(value: unknown): LocalServiceCloudTarget | null;
+export declare function localServiceCloudTargetsEqual(left: LocalServiceCloudTarget | null | undefined, right: LocalServiceCloudTarget | null | undefined): boolean;

package/dist/config/localServiceCloudTarget.js

@@ -0,0 +1,76 @@
+import { TASKFORCE_CLOUD_ENVIRONMENTS, parseTaskforceCloudEnvironment, resolveTaskforceCloudEnvironmentFromBaseUrl, } from './cloudEnvironment.js';
+import { resolveDeploymentConfig } from './deployment.js';
+function normalizeCloudBaseUrl(raw, label) {
+    let parsed;
+    try {
+        parsed = new URL(String(raw || '').trim());
+    }
+    catch {
+        throw new Error(`${label} must be a valid HTTP(S) URL.`);
+    }
+    if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username || parsed.password) {
+        throw new Error(`${label} must be an HTTP(S) URL without embedded credentials.`);
+    }
+    if (parsed.search || parsed.hash) {
+        throw new Error(`${label} must not include a query string or fragment.`);
+    }
+    const pathname = parsed.pathname.replace(/\/+$/, '');
+    return pathname ? `${parsed.origin}${pathname}` : parsed.origin;
+}
+export function resolveLocalServiceCloudTarget(env) {
+    const rawEnvironment = String(env.TASKFORCE_CLOUD_ENVIRONMENT || '').trim();
+    const explicitEnvironment = parseTaskforceCloudEnvironment(rawEnvironment);
+    if (rawEnvironment && !explicitEnvironment) {
+        throw new Error(`Unknown Taskforce cloud environment: ${rawEnvironment}.`);
+    }
+    const deployment = resolveDeploymentConfig(env);
+    const productionOrigin = TASKFORCE_CLOUD_ENVIRONMENTS.production.appBaseUrl;
+    const cloudProxyBaseUrl = normalizeCloudBaseUrl(deployment.cloudBaseUrl || productionOrigin, 'Taskforce cloud proxy URL');
+    const cloudAuthBaseUrl = normalizeCloudBaseUrl(deployment.cloudAuthBaseUrl || cloudProxyBaseUrl, 'Taskforce cloud auth URL');
+    const proxyEnvironment = resolveTaskforceCloudEnvironmentFromBaseUrl(cloudProxyBaseUrl);
+    const authEnvironment = resolveTaskforceCloudEnvironmentFromBaseUrl(cloudAuthBaseUrl);
+    const knownEnvironments = [explicitEnvironment, proxyEnvironment, authEnvironment]
+        .filter((value) => Boolean(value));
+    if (new Set(knownEnvironments).size > 1) {
+        throw new Error('Taskforce cloud environment, proxy URL, and auth URL must identify the same cloud target.');
+    }
+    return {
+        environment: explicitEnvironment || proxyEnvironment || authEnvironment,
+        cloudProxyBaseUrl,
+        cloudAuthBaseUrl,
+    };
+}
+export function applyLocalServiceCloudTarget(env, target) {
+    if (target.environment)
+        env.TASKFORCE_CLOUD_ENVIRONMENT = target.environment;
+    env.TASKFORCE_CLOUD_PROXY_BASE_URL ||= target.cloudProxyBaseUrl;
+    env.VITE_TASKFORCE_CLOUD_AUTH_BASE_URL ||= target.cloudAuthBaseUrl;
+}
+export function parseLocalServiceCloudTarget(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    const environment = record.environment === null
+        ? null
+        : parseTaskforceCloudEnvironment(record.environment);
+    if (record.environment !== null && !environment)
+        return null;
+    if (typeof record.cloudProxyBaseUrl !== 'string' || typeof record.cloudAuthBaseUrl !== 'string')
+        return null;
+    try {
+        const cloudProxyBaseUrl = normalizeCloudBaseUrl(record.cloudProxyBaseUrl, 'Taskforce cloud proxy base URL');
+        const cloudAuthBaseUrl = normalizeCloudBaseUrl(record.cloudAuthBaseUrl, 'Taskforce cloud auth base URL');
+        if (cloudProxyBaseUrl !== record.cloudProxyBaseUrl || cloudAuthBaseUrl !== record.cloudAuthBaseUrl)
+            return null;
+        return { environment, cloudProxyBaseUrl, cloudAuthBaseUrl };
+    }
+    catch {
+        return null;
+    }
+}
+export function localServiceCloudTargetsEqual(left, right) {
+    return Boolean(left && right
+        && left.environment === right.environment
+        && left.cloudProxyBaseUrl === right.cloudProxyBaseUrl
+        && left.cloudAuthBaseUrl === right.cloudAuthBaseUrl);
+}

package/dist/config/localServiceRuntimeContract.d.ts

@@ -0,0 +1,13 @@
+export interface LocalServiceRuntimeContract {
+    schemaVersion: 1;
+    fingerprint: string;
+    coverageVersion: number | null;
+}
+export declare function hydrateSourceCheckoutServiceEnvironment(input: {
+    env: NodeJS.ProcessEnv;
+    projectRoot: string;
+    packageRoot: string;
+}): string | null;
+export declare function resolveLocalServiceRuntimeContract(env: NodeJS.ProcessEnv): LocalServiceRuntimeContract;
+export declare function parseLocalServiceRuntimeContract(value: unknown): LocalServiceRuntimeContract | null;
+export declare function localServiceRuntimeContractsEqual(left: LocalServiceRuntimeContract | null | undefined, right: LocalServiceRuntimeContract | null | undefined): boolean;

package/dist/config/localServiceRuntimeContract.js

@@ -0,0 +1,135 @@
+import { createHash } from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseTaskforceCloudEnvironment } from './cloudEnvironment.js';
+const SERVICE_ENV_EXACT_KEYS = new Set([
+    'CF_ACCESS_CLIENT_ID',
+    'CF_ACCESS_CLIENT_SECRET',
+    'TASKFORCE_CF_ACCESS_CLIENT_ID',
+    'TASKFORCE_CF_ACCESS_CLIENT_SECRET',
+    'TASKFORCE_REALTIME_SYNC',
+    'TASKFORCE_RUNTIME_MODE',
+]);
+function isServiceEnvironmentKey(key) {
+    if (SERVICE_ENV_EXACT_KEYS.has(key))
+        return true;
+    if (key.startsWith('TASKFORCE_E2E_') || key.startsWith('TASKFORCE_PLAYWRIGHT_'))
+        return false;
+    return key.startsWith('TASKFORCE_SYNC_')
+        || key.startsWith('TASKFORCE_LOCAL_SYNC_')
+        || key.startsWith('VITE_TASKFORCE_');
+}
+function isContractKey(key) {
+    return key === 'TASKFORCE_RUNTIME_MODE'
+        || key === 'TASKFORCE_REALTIME_SYNC'
+        || key.startsWith('TASKFORCE_SYNC_')
+        || key.startsWith('TASKFORCE_LOCAL_SYNC_');
+}
+function stripQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2) {
+        const first = trimmed[0];
+        const last = trimmed[trimmed.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return trimmed.slice(1, -1);
+        }
+    }
+    return trimmed;
+}
+function isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function loadTrustedEnvFile(filePath, packageRoot, loaded, visited) {
+    const resolved = fs.realpathSync(filePath);
+    if (!isInside(packageRoot, resolved) || !path.basename(resolved).startsWith('.env')) {
+        throw new Error('Taskforce source-checkout environment includes must remain trusted .env files inside the package root.');
+    }
+    if (visited.has(resolved))
+        return;
+    visited.add(resolved);
+    const lines = fs.readFileSync(resolved, 'utf8').split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const include = trimmed.match(/^(?:\.|source)\s+([^\s]+)$/);
+        if (include) {
+            const includePath = path.resolve(path.dirname(resolved), stripQuotes(include[1]));
+            loadTrustedEnvFile(includePath, packageRoot, loaded, visited);
+            continue;
+        }
+        const normalized = trimmed.startsWith('export ') ? trimmed.slice(7).trim() : trimmed;
+        const separator = normalized.indexOf('=');
+        if (separator <= 0)
+            continue;
+        const key = normalized.slice(0, separator).trim();
+        if (!/^[A-Z][A-Z0-9_]*$/.test(key) || !isServiceEnvironmentKey(key))
+            continue;
+        loaded.set(key, stripQuotes(normalized.slice(separator + 1)));
+    }
+}
+export function hydrateSourceCheckoutServiceEnvironment(input) {
+    const projectRoot = fs.realpathSync(input.projectRoot);
+    const packageRoot = fs.realpathSync(input.packageRoot);
+    if (projectRoot !== packageRoot)
+        return null;
+    const environment = parseTaskforceCloudEnvironment(input.env.TASKFORCE_CLOUD_ENVIRONMENT);
+    if (environment !== 'performance' && environment !== 'staging')
+        return null;
+    const envFile = path.join(packageRoot, `.env.${environment}`);
+    if (!fs.existsSync(envFile))
+        return null;
+    const explicitKeys = new Set(Object.keys(input.env));
+    const loaded = new Map();
+    loadTrustedEnvFile(envFile, packageRoot, loaded, new Set());
+    for (const [key, value] of loaded) {
+        if (!explicitKeys.has(key))
+            input.env[key] = value;
+    }
+    return envFile;
+}
+export function resolveLocalServiceRuntimeContract(env) {
+    const effectiveEnv = {
+        ...env,
+        TASKFORCE_RUNTIME_MODE: String(env.TASKFORCE_RUNTIME_MODE || 'local').trim().toLowerCase(),
+    };
+    const entries = Object.entries(effectiveEnv)
+        .filter(([key, value]) => isContractKey(key) && value !== undefined)
+        .map(([key, value]) => [key, String(value)])
+        .sort(([left], [right]) => left.localeCompare(right));
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify(entries))
+        .digest('hex');
+    const rawCoverageVersion = Number.parseInt(String(env.TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION || ''), 10);
+    return {
+        schemaVersion: 1,
+        fingerprint,
+        coverageVersion: Number.isSafeInteger(rawCoverageVersion) && rawCoverageVersion > 0
+            ? rawCoverageVersion
+            : null,
+    };
+}
+export function parseLocalServiceRuntimeContract(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.schemaVersion !== 1
+        || typeof record.fingerprint !== 'string'
+        || !/^[a-f0-9]{64}$/.test(record.fingerprint)
+        || (record.coverageVersion !== null
+            && (!Number.isSafeInteger(record.coverageVersion) || Number(record.coverageVersion) < 1))) {
+        return null;
+    }
+    return {
+        schemaVersion: 1,
+        fingerprint: record.fingerprint,
+        coverageVersion: record.coverageVersion === null ? null : Number(record.coverageVersion),
+    };
+}
+export function localServiceRuntimeContractsEqual(left, right) {
+    return Boolean(left && right
+        && left.schemaVersion === right.schemaVersion
+        && left.fingerprint === right.fingerprint
+        && left.coverageVersion === right.coverageVersion);
+}

package/dist/core/AiProfileService.d.ts

@@ -138,6 +138,7 @@ export declare function getAiProfileByConnectionService(deps: AiProfileServiceDe
     workspaceId: string;
     connectionId: string;
     seatScope?: AiProfileSeatScope | null;
+    repairLegacyBinding?: boolean;
 }): AiProfileRecordLike | null;
 export declare function archiveAiProfileService(deps: AiProfileServiceDeps, input: {
     workspaceId: string;

package/dist/core/AiProfileService.js

@@ -931,15 +931,27 @@ function reconcileSyncedAiProfileConnectionBindings(deps, workspaceId, profileId
             .sort()
         : [];
     const clientId = String(connection.clientId || '').trim() || null;
-    if (bindingIds.length === 0) {
-        deps.db.prepare(`DELETE FROM ai_profile_connection_bindings WHERE tenant_id = ? AND workspace_id = ? AND profile_id = ?`)
+    // Credential-derived bindings are authentication state owned by the cloud
+    // runtime. Synced profile metadata must never create, remove, or reassign
+    // them; doing so would let a stale replica change write attribution.
+    const syncedBindingIds = bindingIds.filter((bindingId) => !isCredentialOwnedConnectionBindingId(bindingId));
+    if (syncedBindingIds.length === 0) {
+        deps.db.prepare(`DELETE FROM ai_profile_connection_bindings
+            WHERE tenant_id = ? AND workspace_id = ? AND profile_id = ?
+              AND connection_id NOT LIKE 'oauth:%'
+              AND connection_id NOT LIKE 'oauth-client:%'
+              AND connection_id NOT LIKE 'token:%'`)
             .run(deps.tenantId, workspaceId, profileId);
         return;
     }
-    const placeholders = bindingIds.map(() => '?').join(', ');
+    const placeholders = syncedBindingIds.map(() => '?').join(', ');
     deps.db.prepare(`DELETE FROM ai_profile_connection_bindings
-        WHERE tenant_id = ? AND workspace_id = ? AND profile_id = ? AND connection_id NOT IN (${placeholders})`)
-        .run(deps.tenantId, workspaceId, profileId, ...bindingIds);
+        WHERE tenant_id = ? AND workspace_id = ? AND profile_id = ?
+          AND connection_id NOT LIKE 'oauth:%'
+          AND connection_id NOT LIKE 'oauth-client:%'
+          AND connection_id NOT LIKE 'token:%'
+          AND connection_id NOT IN (${placeholders})`)
+        .run(deps.tenantId, workspaceId, profileId, ...syncedBindingIds);
     const now = new Date().toISOString();
     const upsert = deps.db.prepare(`INSERT INTO ai_profile_connection_bindings
         (tenant_id, workspace_id, connection_id, profile_id, client_id, created_at, updated_at)
@@ -948,7 +960,7 @@ function reconcileSyncedAiProfileConnectionBindings(deps, workspaceId, profileId
             profile_id = excluded.profile_id,
             client_id = excluded.client_id,
             updated_at = excluded.updated_at`);
-    for (const bindingId of bindingIds) {
+    for (const bindingId of syncedBindingIds) {
         upsert.run(deps.tenantId, workspaceId, bindingId, profileId, clientId, now, now);
     }
 }
@@ -1282,6 +1294,11 @@ function normalizeConnectionBindingId(deps, value) {
     }
     return normalized;
 }
+function isCredentialOwnedConnectionBindingId(connectionId) {
+    return connectionId.startsWith('oauth:')
+        || connectionId.startsWith('oauth-client:')
+        || connectionId.startsWith('token:');
+}
 function parseProviderMetadataRow(row) {
     if (typeof row.provider_metadata_json !== 'string' || !row.provider_metadata_json.trim())
         return {};
@@ -1304,10 +1321,29 @@ export function bindAiProfileConnectionService(deps, input) {
         if (!target)
             throw deps.createRuleError(`Profile ${profileId} not found`, 404, 'AI_PROFILE_NOT_FOUND');
         const now = new Date().toISOString();
-        deps.db.prepare(`INSERT INTO ai_profile_connection_bindings (tenant_id, workspace_id, connection_id, profile_id, client_id, created_at, updated_at)
+        deps.db.prepare(`INSERT INTO ai_profile_connection_bindings
+            (tenant_id, workspace_id, connection_id, profile_id, client_id, created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT (tenant_id, workspace_id, connection_id) DO UPDATE SET profile_id = excluded.profile_id, client_id = excluded.client_id, updated_at = excluded.updated_at`)
+            ON CONFLICT (tenant_id, workspace_id, connection_id) DO NOTHING`)
             .run(deps.tenantId, workspaceId, connectionId, profileId, clientId, now, now);
+        const existing = deps.db.prepare(`SELECT b.profile_id, p.archived_at
+            FROM ai_profile_connection_bindings b
+            LEFT JOIN ai_profiles p ON p.tenant_id = b.tenant_id AND p.workspace_id = b.workspace_id AND p.id = b.profile_id
+            WHERE b.tenant_id = ? AND b.workspace_id = ? AND b.connection_id = ? LIMIT 1`)
+            .get(deps.tenantId, workspaceId, connectionId);
+        if (!existing?.profile_id) {
+            throw deps.createRuleError('Failed to establish the MCP connection binding.', 500, 'AI_PROFILE_CONNECTION_BIND_FAILED');
+        }
+        if (existing && existing.profile_id !== profileId && !existing.archived_at) {
+            throw deps.createRuleError('This MCP connection is already bound to a different active AI profile. Reconnect or use an authorized profile recovery flow.', 409, 'AI_PROFILE_CONNECTION_CONFLICT', { workspaceId, connectionId, existingProfileId: existing.profile_id || null, requestedProfileId: profileId });
+        }
+        const updateResult = deps.db.prepare(`UPDATE ai_profile_connection_bindings
+            SET profile_id = ?, client_id = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND connection_id = ? AND profile_id = ?`)
+            .run(profileId, clientId, now, deps.tenantId, workspaceId, connectionId, existing.profile_id);
+        if (updateResult.changes !== 1) {
+            throw deps.createRuleError('The MCP connection binding changed concurrently. Retry after refreshing the intended profile.', 409, 'AI_PROFILE_CONNECTION_CONFLICT', { workspaceId, connectionId, expectedProfileId: existing.profile_id || null, requestedProfileId: profileId });
+        }
         const rows = deps.db.prepare(`SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ?`).all(deps.tenantId, workspaceId);
         for (const row of rows) {
             const metadata = parseProviderMetadataRow(row);
@@ -1351,6 +1387,8 @@ export function getAiProfileByConnectionService(deps, input) {
         const record = hydrateAiProfileRecord(deps, binding);
         return input.seatScope !== undefined && (record.seatScope ?? null) !== input.seatScope ? null : record;
     }
+    if (isCredentialOwnedConnectionBindingId(connectionId))
+        return null;
     const legacyRows = deps.db.prepare(`SELECT * FROM ai_profiles WHERE tenant_id = ? AND workspace_id = ?`).all(deps.tenantId, workspaceId)
         .filter((row) => {
         const record = hydrateAiProfileRecord(deps, row);
@@ -1367,8 +1405,9 @@ export function getAiProfileByConnectionService(deps, input) {
     if (legacyRows.length === 0)
         return null;
     const record = hydrateAiProfileRecord(deps, legacyRows[0]);
-    if (!record.archivedAt)
+    if (!record.archivedAt && input.repairLegacyBinding !== false) {
         bindAiProfileConnectionService(deps, { workspaceId, profileId: record.id, connectionId });
+    }
     return record;
 }
 export function archiveAiProfileService(deps, input) {

package/dist/core/AttachmentLinkService.js

@@ -262,11 +262,14 @@ export function syncCanonicalAttachmentLinksForTargetService(deps, targetType, t
                         : String(row?.kind || '').trim() === 'image'
                             ? 'image'
                             : 'attachment';
-        const displayName = String(row?.kind || '').trim() === 'document' && !isExternalStorageKey
+        const displayName = typeof attachment === 'string'
             ? null
-            : (typeof attachment === 'string'
-                ? null
-                : buildAttachmentDisplayName(attachment, isExternalStorageKey || !storageKey ? null : path.basename(storageKey)));
+            : safeTargetType === 'task'
+                ? String(attachment.displayName || attachment.originalFilename || attachment.caption
+                    || (isExternalStorageKey || !storageKey ? '' : path.basename(storageKey))).trim() || null
+                : String(row?.kind || '').trim() === 'document' && !isExternalStorageKey
+                    ? null
+                    : buildAttachmentDisplayName(attachment, isExternalStorageKey || !storageKey ? null : path.basename(storageKey));
         const timestamp = typeof attachment === 'string' ? new Date().toISOString() : (attachment.timestamp || new Date().toISOString());
         upsertLink.run(deps.tenantId, normalizedWorkspaceId, assetId, safeTargetType, normalizedTargetId, role, displayName, index, timestamp, timestamp);
     });

package/dist/core/DeletedTaskLifecycleService.d.ts

@@ -8,6 +8,7 @@ export interface DeletedTaskLifecycleServiceDeps {
     generateEntityId: (prefix: string) => string;
     normalizeWorkspaceId: (workspaceId: string | undefined) => string;
     resolveWorkspaceActor: (workspaceId: string, actorRef: unknown) => TaskActor | null;
+    resolveWorkspaceActors: (workspaceId: string, actorRefs: unknown[]) => Map<string, TaskActor | null>;
     sanitizeOrderInDay: (value: unknown) => number | null;
     sanitizeDateOnly: (value: unknown) => string | null;
     normalizeTaskEventActor: (actorRef: unknown, workspaceId: string) => {
@@ -16,6 +17,7 @@ export interface DeletedTaskLifecycleServiceDeps {
         actorProfile: TaskActor | null;
     };
     runRetentionPurgeTransaction: <T>(workspaceId: string | null, apply: (durableDeleteOwnedKeys: ReadonlySet<string>) => T) => T;
+    listDurableDeleteOwnedTaskIds: (workspaceId: string) => ReadonlySet<string>;
 }
 export declare function normalizeTaskSnapshotForRestoreService(deps: DeletedTaskLifecycleServiceDeps, task: TaskItem): TaskItem;
 export declare function normalizeDeletedTaskRestoreLifecycleService(deps: DeletedTaskLifecycleServiceDeps, task: TaskItem): Pick<TaskItem, 'status' | 'isArchived' | 'completedAt' | 'canceledReason'>;
@@ -33,4 +35,7 @@ export declare function addDeletedTaskRecordService(deps: DeletedTaskLifecycleSe
 export declare function listDeletedTasksService(deps: DeletedTaskLifecycleServiceDeps, workspaceId?: string): {
     deleted: DeletedTaskRecord[];
 };
+export declare function listDeletedTasksReadOnlyService(deps: DeletedTaskLifecycleServiceDeps, workspaceId?: string): {
+    deleted: DeletedTaskRecord[];
+};
 export declare function getDeletedTaskService(deps: DeletedTaskLifecycleServiceDeps, id: string, workspaceId?: string): DeletedTaskRecord | null;

package/dist/core/DeletedTaskLifecycleService.js

@@ -119,6 +119,41 @@ export function mapDeletedTaskRowService(deps, row) {
         actorProfile: actor === 'system' ? null : deps.resolveWorkspaceActor(workspaceId, actor)
     };
 }
+function mapDeletedTaskRowsService(deps, rows) {
+    const actorProfiles = new Map();
+    const actorRefsByWorkspace = new Map();
+    for (const row of rows) {
+        const workspaceId = deps.normalizeWorkspaceId(typeof row.workspace_id === 'string' ? row.workspace_id : undefined);
+        const actorRef = String(row.actor || 'system').trim() || 'system';
+        if (actorRef === 'system') {
+            actorProfiles.set(`${workspaceId}\u0000${actorRef}`, null);
+            continue;
+        }
+        const workspaceActorRefs = actorRefsByWorkspace.get(workspaceId) ?? new Set();
+        workspaceActorRefs.add(actorRef);
+        actorRefsByWorkspace.set(workspaceId, workspaceActorRefs);
+    }
+    for (const [workspaceId, actorRefs] of actorRefsByWorkspace) {
+        const resolvedWorkspaceActors = deps.resolveWorkspaceActors(workspaceId, [...actorRefs]);
+        for (const actorRef of actorRefs) {
+            actorProfiles.set(`${workspaceId}\u0000${actorRef}`, resolvedWorkspaceActors.get(actorRef) ?? null);
+        }
+    }
+    const cachedDeps = {
+        ...deps,
+        resolveWorkspaceActor: (workspaceId, actorRef) => {
+            const cacheKey = `${workspaceId}\u0000${String(actorRef || '').trim()}`;
+            if (actorProfiles.has(cacheKey))
+                return actorProfiles.get(cacheKey) ?? null;
+            const actorProfile = deps.resolveWorkspaceActor(workspaceId, actorRef);
+            actorProfiles.set(cacheKey, actorProfile);
+            return actorProfile;
+        },
+    };
+    return rows
+        .map((row) => mapDeletedTaskRowService(cachedDeps, row))
+        .filter((row) => Boolean(row));
+}
 function deletedTaskListSnapshotSelect() {
     const snapshotPairs = DELETED_TASK_LIST_SNAPSHOT_FIELDS
         .map((field) => `'${field}', snapshot -> '${field}'`)
@@ -220,9 +255,26 @@ export function listDeletedTasksService(deps, workspaceId) {
     `;
     const rows = deps.db.prepare(listSql).all(deps.tenantId, normalizedWorkspaceId);
     return {
-        deleted: rows
-            .map((row) => mapDeletedTaskRowService(deps, row))
-            .filter((row) => Boolean(row))
+        deleted: mapDeletedTaskRowsService(deps, rows)
+    };
+}
+export function listDeletedTasksReadOnlyService(deps, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const cutoff = new Date(Date.now() - (DELETED_TASK_RETENTION_DAYS * 24 * 60 * 60 * 1000)).toISOString();
+    const durableDeleteOwnedTaskIds = deps.listDurableDeleteOwnedTaskIds(normalizedWorkspaceId);
+    const listSql = deps.db.provider === 'postgres'
+        ? deletedTaskListSnapshotSelect()
+        : `
+        SELECT *
+        FROM deleted_tasks
+        WHERE tenant_id = ?
+          AND workspace_id = ?
+        ORDER BY deleted_at DESC, id DESC
+    `;
+    const rows = deps.db.prepare(listSql).all(deps.tenantId, normalizedWorkspaceId);
+    return {
+        deleted: mapDeletedTaskRowsService(deps, rows)
+            .filter((row) => row.deletedAt >= cutoff || durableDeleteOwnedTaskIds.has(row.taskId))
     };
 }
 export function getDeletedTaskService(deps, id, workspaceId) {

package/dist/core/McpTokenService.d.ts

@@ -124,6 +124,10 @@ export declare class McpTokenService {
         profileToken: string;
         profileName: string;
     }): boolean;
+    listMcpOAuthRestorableAiProfileIds(input: {
+        grantId: string;
+        workspaceId: string;
+    }): string[];
     recordMcpOAuthConnectorGrantUsage(input: {
         grantId: string;
         workspaceId: string;

package/dist/core/McpTokenService.js

@@ -973,6 +973,58 @@ export class McpTokenService {
         `).run(profileId, profileToken, profileName, now, this.tenantId, workspaceId, grantId);
         return Number(result?.changes || 0) > 0;
     }
+    listMcpOAuthRestorableAiProfileIds(input) {
+        const grantId = String(input.grantId || '').trim();
+        const workspaceId = String(input.workspaceId || '').trim();
+        if (!grantId || !workspaceId)
+            return [];
+        const current = this.db.prepare(`
+            SELECT current.provider, current.user_id, current_client.client_name,
+                   current_client.redirect_uris_json, current_client.product_client_id
+            FROM mcp_oauth_connector_grants current
+            JOIN mcp_oauth_clients current_client
+              ON current_client.tenant_id = current.tenant_id
+             AND current_client.id = current.client_id
+            WHERE current.tenant_id = ?
+              AND current.workspace_id = ?
+              AND current.id = ?
+              AND current.status = 'active'
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, grantId);
+        if (!current?.provider || !current.user_id)
+            return [];
+        const canonicalRedirectUris = (value) => {
+            try {
+                const parsed = JSON.parse(String(value || '[]'));
+                if (!Array.isArray(parsed))
+                    return null;
+                return JSON.stringify([...new Set(parsed.map((uri) => String(uri || '').trim()).filter(Boolean))].sort());
+            }
+            catch {
+                return null;
+            }
+        };
+        const currentRedirectUris = canonicalRedirectUris(current.redirect_uris_json);
+        if (!currentRedirectUris)
+            return [];
+        const previousRows = this.db.prepare(`
+            SELECT previous.ai_profile_id, previous_client.client_name,
+                   previous_client.redirect_uris_json, previous_client.product_client_id
+            FROM mcp_oauth_connector_grants previous
+            JOIN mcp_oauth_clients previous_client
+              ON previous_client.tenant_id = previous.tenant_id
+             AND previous_client.id = previous.client_id
+            WHERE previous.tenant_id = ?
+              AND previous.workspace_id = ?
+              AND previous.user_id = ?
+              AND previous.provider = ?
+              AND previous.id <> ?
+              AND previous.ai_profile_id IS NOT NULL
+        `).all(this.tenantId, workspaceId, String(current.user_id), String(current.provider), grantId);
+        return [...new Set(previousRows.filter((row) => (String(row.client_name || '') === String(current.client_name || '')
+                && String(row.product_client_id || '') === String(current.product_client_id || '')
+                && canonicalRedirectUris(row.redirect_uris_json) === currentRedirectUris)).map((row) => String(row.ai_profile_id || '').trim()).filter(Boolean))].sort();
+    }
     recordMcpOAuthConnectorGrantUsage(input) {
         const grantId = String(input.grantId || '').trim();
         const workspaceId = String(input.workspaceId || '').trim();