@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/components/views/standalone/modals/SyncStatusModal.js

@@ -1,18 +1,28 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from 'react';
-import { AlertTriangle, ChevronDown, Copy, Loader2, RefreshCw } from 'lucide-react';
+import { AlertTriangle, ChevronDown, Copy, Loader2 } from 'lucide-react';
 import { Modal } from '../../../ui/Modal';
 import modalStyles from '../../../ui/Modal.module.css';
 import syncStatusStyles from '../../SyncStatusModal.module.css';
 import styles from '../../../../Taskforce.module.css';
 import { isWorkspaceSyncAuthenticationError } from '../../../../utils/workspaceSyncPresentation';
-export function SyncStatusModal({ isOpen, theme, currentWorkspaceLabel, syncStatus, syncStatusMeta, workspaceCloudSyncEnabled, syncControlBusy, canManageWorkspaceSync, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncRepairBusy, referenceMismatchCount, syncStageLabel, workspaceSyncPendingChanges, incomingCloudChanges, formattedLastSyncTime, formattedLastPullTime, formattedLastPushTime, syncLastError, activeReferenceMismatchSummaries, syncDiagnosticsSummary, syncEventRows, syncEventsListRef, workspaceSyncRepairQueued, workspaceSyncBusy, workspaceSyncCopied, coordinatorOwnershipMode, coordinatorOwnershipTransferBusy, coordinatorOwnershipTransferDisabled, onClose, onToggleWorkspaceSync, onRepairSync, onCopyReport, onRetrySync, onTransferCoordinatorOwnership, }) {
+export function SyncStatusModal({ isOpen, theme, currentWorkspaceLabel, syncStatus, syncStatusMeta, workspaceCloudSyncEnabled, syncControlBusy, syncControlIntent, canManageWorkspaceSync, workspaceSyncSummary, workspaceSyncRecommendedAction, workspaceSyncRepairBusy, referenceMismatchCount, syncStageLabel, workspaceSyncPendingChanges, incomingCloudChanges, formattedLastSyncTime, formattedLastPullTime, formattedLastPushTime, syncLastError, activeReferenceMismatchSummaries, syncDiagnosticsSummary, syncEventRows, syncEventsListRef, workspaceSyncRepairQueued, workspaceSyncBusy, workspaceSyncCopied, coordinatorOwnershipMode, coordinatorOwnershipTransferBusy, coordinatorOwnershipTransferDisabled, onClose, onToggleWorkspaceSync, onRepairSync, onCopyReport, onTransferCoordinatorOwnership, }) {
     const [eventFilter, setEventFilter] = useState('all');
     useEffect(() => {
         if (isOpen)
             setEventFilter('all');
     }, [isOpen]);
     const needsAttention = syncStatus === 'attention';
+    const displayedSyncEnabled = syncControlIntent === 'enabling'
+        ? true
+        : syncControlIntent === 'disabling'
+            ? false
+            : workspaceCloudSyncEnabled;
+    const syncControlTransitionLabel = syncControlIntent === 'enabling'
+        ? 'Turning on…'
+        : syncControlIntent === 'disabling'
+            ? 'Turning off…'
+            : null;
     const activeIssue = workspaceSyncRepairBusy
         ? referenceMismatchCount > 0
             ? `Repair is reconciling cloud state, including ${referenceMismatchCount} reference mismatch${referenceMismatchCount === 1 ? '' : 'es'}.`
@@ -26,58 +36,43 @@ export function SyncStatusModal({ isOpen, theme, currentWorkspaceLabel, syncStat
     const coordinatorOwnedByOtherProcess = /\banother local taskforce process owns workspace synchronization\b/i.test(syncLastError);
     const coordinatorAuthenticationRequired = isWorkspaceSyncAuthenticationError(syncLastError);
     const repairActionAvailable = workspaceCloudSyncEnabled
+        && syncStatus !== 'checking'
         && !coordinatorOwnedByOtherProcess
         && !coordinatorAuthenticationRequired
         && (needsAttention
             || workspaceSyncBusy
             || workspaceSyncRepairBusy
             || workspaceSyncRepairQueued);
-    const retryActionAvailable = workspaceCloudSyncEnabled
-        && !coordinatorOwnedByOtherProcess
-        && !coordinatorAuthenticationRequired
-        && (workspaceSyncBusy
-            || needsAttention
-            || /\bpress sync\b/i.test(workspaceSyncRecommendedAction));
     const visibleEventRows = useMemo(() => eventFilter === 'issues'
         ? syncEventRows.filter((row) => row.tone === 'error')
         : syncEventRows, [eventFilter, syncEventRows]);
-    const footer = (_jsxs("div", { className: syncStatusStyles.syncStatusFooter, children: [_jsxs("button", { className: styles.cancelBtn, onClick: onCopyReport, title: "Copy the current sync manager report for support or AI troubleshooting.", children: [_jsx(Copy, { size: 14 }), _jsx("span", { children: workspaceSyncCopied ? 'Copied' : 'Copy Report' })] }), _jsxs("div", { className: syncStatusStyles.syncStatusFooterPrimary, children: [_jsx("button", { className: styles.cancelBtn, onClick: onRepairSync, disabled: !repairActionAvailable
-                            || workspaceSyncRepairBusy
-                            || workspaceSyncRepairQueued, title: workspaceSyncRepairBusy
-                            ? 'Repair is running now.'
-                            : workspaceSyncRepairQueued
-                                ? 'Repair is queued and will start when the current sync finishes.'
-                                : !workspaceCloudSyncEnabled
-                                    ? 'Turn on workspace sync before running Repair.'
-                                    : coordinatorOwnedByOtherProcess
-                                        ? 'Repair is unavailable in this process. Use the Taskforce process that owns workspace synchronization.'
-                                        : coordinatorAuthenticationRequired
-                                            ? 'Sign out and sign back in before running Repair.'
-                                            : workspaceSyncBusy
-                                                ? 'Queue a repair to start automatically when the current sync finishes.'
-                                                : !repairActionAvailable
-                                                    ? 'Repair is available when sync needs attention.'
-                                                    : 'Advanced recovery: clear the saved pull cursor and re-fetch cloud state from the beginning.', children: workspaceSyncRepairBusy ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { size: 14, className: styles.spinner }), "Repairing..."] })) : workspaceSyncRepairQueued ? ('Repair Queued') : ('Repair') }), _jsx("button", { className: styles.submitBtn, onClick: onRetrySync, disabled: !retryActionAvailable || workspaceSyncBusy, title: workspaceSyncBusy
-                            ? 'A sync request is already running.'
+    const footer = (_jsxs("div", { className: syncStatusStyles.syncStatusFooter, children: [_jsxs("button", { className: styles.cancelBtn, onClick: onCopyReport, title: "Copy the current sync manager report for support or AI troubleshooting.", children: [_jsx(Copy, { size: 14 }), _jsx("span", { children: workspaceSyncCopied ? 'Copied' : 'Copy Report' })] }), _jsx("div", { className: syncStatusStyles.syncStatusFooterPrimary, children: _jsx("button", { className: styles.cancelBtn, onClick: onRepairSync, disabled: !repairActionAvailable
+                        || workspaceSyncRepairBusy
+                        || workspaceSyncRepairQueued, title: workspaceSyncRepairBusy
+                        ? 'Repair is running now.'
+                        : workspaceSyncRepairQueued
+                            ? 'Repair is queued and will start when the current sync finishes.'
                             : !workspaceCloudSyncEnabled
-                                ? 'Turn on workspace sync before retrying.'
+                                ? 'Turn on workspace sync before running Repair.'
                                 : coordinatorOwnedByOtherProcess
-                                    ? 'Retry is unavailable in this process. Use the Taskforce process that owns workspace synchronization.'
+                                    ? 'Repair is unavailable in this process. Use the Taskforce process that owns workspace synchronization.'
                                     : coordinatorAuthenticationRequired
-                                        ? 'Sign out and sign back in before retrying sync.'
-                                        : !retryActionAvailable
-                                            ? 'No retry is currently needed.'
-                                            : 'Retry workspace synchronization now.', children: workspaceSyncBusy ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { size: 14, className: styles.spinner }), "Syncing..."] })) : (_jsxs(_Fragment, { children: [_jsx(RefreshCw, { size: 14 }), "Retry now"] })) })] })] }));
+                                        ? 'Sign out and sign back in before running Repair.'
+                                        : workspaceSyncBusy
+                                            ? 'Queue a repair to start automatically when the current sync finishes.'
+                                            : !repairActionAvailable
+                                                ? 'Repair is available when sync needs attention.'
+                                                : 'Advanced recovery: clear the saved pull cursor and re-fetch cloud state from the beginning.', children: workspaceSyncRepairBusy ? (_jsxs(_Fragment, { children: [_jsx(Loader2, { size: 14, className: styles.spinner }), "Repairing..."] })) : workspaceSyncRepairQueued ? ('Repair Queued') : ('Repair') }) })] }));
     return (_jsx(Modal, { isOpen: isOpen, onClose: onClose, title: "Sync Manager", size: "mdWide", theme: theme, draggable: true, className: syncStatusStyles.syncStatusOverlay, footer: footer, children: _jsxs("div", { className: `${modalStyles.form} ${syncStatusStyles.syncStatusModal}`, children: [_jsxs("div", { className: syncStatusStyles.syncStatusTop, children: [_jsxs("div", { className: syncStatusStyles.syncStatusMetaHeader, children: [_jsx("div", { className: syncStatusStyles.syncStatusBadge, style: {
                                         borderColor: syncStatusMeta.border,
                                         background: syncStatusMeta.background,
                                         color: syncStatusMeta.color
-                                    }, children: syncStatusMeta.label }), _jsxs("span", { className: syncStatusStyles.syncStatusLabel, children: ["Workspace: ", _jsx("code", { children: currentWorkspaceLabel })] })] }), _jsx("label", { className: syncStatusStyles.syncToggle, children: _jsxs("span", { className: [
-                                    syncStatusStyles.syncToggleControl,
-                                    workspaceCloudSyncEnabled ? syncStatusStyles.syncToggleControlEnabled : syncStatusStyles.syncToggleControlDisabled,
-                                    syncControlBusy ? syncStatusStyles.syncToggleControlBusy : '',
-                                    !canManageWorkspaceSync ? syncStatusStyles.syncToggleControlBlocked : ''
-                                ].filter(Boolean).join(' '), children: [_jsx("input", { className: syncStatusStyles.syncToggleInput, type: "checkbox", role: "switch", "aria-label": "Enable Sync", checked: workspaceCloudSyncEnabled, disabled: !canManageWorkspaceSync || syncControlBusy, onChange: (event) => onToggleWorkspaceSync(event.target.checked) }), _jsx("span", { className: `${syncStatusStyles.syncToggleState} ${syncStatusStyles.syncToggleStateOn}`, children: "On" }), _jsx("span", { className: `${syncStatusStyles.syncToggleState} ${syncStatusStyles.syncToggleStateOff}`, children: "Off" }), _jsx("span", { className: syncStatusStyles.syncToggleThumb })] }) })] }), _jsxs("section", { className: syncStatusStyles.syncStatusOverview, "aria-label": "Sync status", children: [_jsxs("div", { className: syncStatusStyles.syncStatusOverviewRow, children: [_jsx("span", { className: syncStatusStyles.syncStatusLabel, children: "Health" }), _jsx("span", { className: syncStatusStyles.syncStatusSummaryValue, children: workspaceSyncSummary })] }), _jsxs("div", { className: syncStatusStyles.syncStatusOverviewRow, children: [_jsx("span", { className: syncStatusStyles.syncStatusLabel, children: "Next step" }), _jsx("span", { className: syncStatusStyles.syncStatusSummaryValue, children: workspaceSyncRecommendedAction })] }), _jsxs("div", { className: [
+                                    }, children: syncStatusMeta.label }), _jsxs("span", { className: syncStatusStyles.syncStatusLabel, children: ["Workspace: ", _jsx("code", { children: currentWorkspaceLabel })] })] }), _jsxs("label", { className: syncStatusStyles.syncToggle, children: [syncControlTransitionLabel ? (_jsx("span", { className: syncStatusStyles.syncToggleTransition, "aria-live": "polite", children: syncControlTransitionLabel })) : null, _jsxs("span", { className: [
+                                        syncStatusStyles.syncToggleControl,
+                                        displayedSyncEnabled ? syncStatusStyles.syncToggleControlEnabled : syncStatusStyles.syncToggleControlDisabled,
+                                        syncControlBusy ? syncStatusStyles.syncToggleControlBusy : '',
+                                        !canManageWorkspaceSync ? syncStatusStyles.syncToggleControlBlocked : ''
+                                    ].filter(Boolean).join(' '), children: [_jsx("input", { className: syncStatusStyles.syncToggleInput, type: "checkbox", role: "switch", "aria-label": syncControlTransitionLabel || 'Enable Sync', checked: displayedSyncEnabled, disabled: !canManageWorkspaceSync || syncControlBusy, onChange: (event) => onToggleWorkspaceSync(event.target.checked) }), _jsx("span", { className: `${syncStatusStyles.syncToggleState} ${syncStatusStyles.syncToggleStateOn}`, children: "On" }), _jsx("span", { className: `${syncStatusStyles.syncToggleState} ${syncStatusStyles.syncToggleStateOff}`, children: "Off" }), _jsx("span", { className: syncStatusStyles.syncToggleThumb })] })] })] }), _jsxs("section", { className: syncStatusStyles.syncStatusOverview, "aria-label": "Sync status", children: [_jsxs("div", { className: syncStatusStyles.syncStatusOverviewRow, children: [_jsx("span", { className: syncStatusStyles.syncStatusLabel, children: "Health" }), _jsx("span", { className: syncStatusStyles.syncStatusSummaryValue, children: workspaceSyncSummary })] }), _jsxs("div", { className: syncStatusStyles.syncStatusOverviewRow, children: [_jsx("span", { className: syncStatusStyles.syncStatusLabel, children: "Next step" }), _jsx("span", { className: syncStatusStyles.syncStatusSummaryValue, children: workspaceSyncRecommendedAction })] }), _jsxs("div", { className: [
                                 syncStatusStyles.syncStatusOverviewRow,
                                 syncStatusStyles.syncStatusIssueRow,
                                 activeIssueIsError ? syncStatusStyles.syncStatusIssueRowError : '',

package/dist/config/envSchema.js

@@ -1,6 +1,7 @@
 import { resolveDeploymentConfig } from './deployment.js';
 import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
 import { parseWorkspaceSyncV3FeedCursorKeyring } from '../sync/v3/workspaceSyncV3FeedCursorKeys.js';
+import { resolveExecutorPhaseAApprovalSigningConfig } from '../services/executorPhaseAApprovalService.js';
 const SPECS = [
     { key: 'PORT', description: 'Standalone server port.', category: 'Core', defaultValue: '8080', targets: ['server', 'all'] },
     { key: 'TASKFORCE_TENANT_ID', description: 'Tenant identifier.', category: 'Core', defaultValue: 'default', targets: ['server', 'all'] },
@@ -66,7 +67,7 @@ const SPECS = [
     { key: 'TASKFORCE_SYNC_V3_LOCAL_FEED_APPLY_ENABLED', description: 'Enable the local-only atomic v3 initiative feed apply boundary.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_COMBINED_FEED_ENABLED', description: 'Expose registered task-planning-metadata cloud feed and repair contracts.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_COMBINED_FEED_ACTIVATION_ENABLED', description: 'Request combined coordinator activation; activation still requires exact local prerequisites and a matching ready cloud capability attestation.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
-    { key: 'TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION', description: 'Request a frozen combined-feed coverage profile by registered version. Omit for version 3; version 4 adds nested task and entity-event coverage; version 5 adds workflow runtime coverage; version 6 extends version 4 with workstream task order.', category: 'Core', defaultValue: '3', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_SYNC_V3_COMBINED_FEED_COVERAGE_VERSION', description: 'Request a frozen combined-feed coverage profile by registered version. Omit for version 3; version 4 adds nested task and entity-event coverage; version 5 adds workflow runtime coverage; version 6 adds workstream task order; version 7 adds explicit task card covers; version 8 composes workflow runtime with version 7.', category: 'Core', defaultValue: '3', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_COMBINED_LOCAL_FEED_APPLY_ENABLED', description: 'Enable local atomic apply for registered task-planning-metadata coverage profiles.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_COMBINED_LEGACY_FENCE_ENABLED', description: 'Configure the combined stale-v2 fence; it becomes effective only after every covered cloud HTTP and MCP writer boundary is ready.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_NESTED_LEGACY_FENCE_ENABLED', description: 'Fence the four v4-only legacy projections after every nested cloud writer boundary is ready.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
@@ -75,6 +76,7 @@ const SPECS = [
     { key: 'TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_DISPATCH_ENABLED', description: 'Enable local durable workflow runtime outbox dispatch when the shared dispatcher is enabled.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_HTTP_ACTIVATION_ENABLED', description: 'Route workflow runtime HTTP commands through durable v3 acceptance or local capture.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_MCP_ACTIVATION_ENABLED', description: 'Route workflow runtime MCP commands through durable v3 acceptance or local capture.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_MUTATIONS_FENCED', description: 'Temporarily reject workflow execution mutations during projection rollback.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_WORKFLOW_RUNTIME_CARRIER_COEXISTENCE_ENABLED', description: 'Acknowledge that task-status workflow activation remains the v5 bootstrap and rollback carrier.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_WORKSTREAM_TASK_ORDER_ENABLED', description: 'Enable cloud acceptance for durable v3 workstream task-order operations.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_V3_WORKSTREAM_TASK_ORDER_CAPTURE_ENABLED', description: 'Enable local durable workstream task-order capture when the shared local capture and dispatch boundaries are enabled.', category: 'Core', defaultValue: 'false', targets: ['server', 'all'] },
@@ -89,6 +91,10 @@ const SPECS = [
     { key: 'TASKFORCE_AUTH_EXCLUDED_PATHS', description: 'Comma-separated API paths excluded from auth checks.', category: 'Auth', defaultValue: '/api/taskforce/health,/api/taskforce/version,/api/taskforce/auth,/api/taskforce/public/pricing,/api/taskforce/public/site-config,/api/taskforce/public/site-config-script', targets: ['server', 'all'] },
     { key: 'TASKFORCE_AUTH_DEFAULT_ROLE', description: 'Default role for unauthenticated context (owner|admin|member|read-only).', category: 'Auth', defaultValue: 'member', targets: ['server', 'all'] },
     { key: 'TASKFORCE_AUTH_SESSION_COOKIE', description: 'Session cookie name.', category: 'Auth', defaultValue: 'taskforce_session', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_ADMIN_PROXY_UPSTREAM_SESSION_COOKIE', description: 'Upstream cloud session cookie name used by every admin proxy target unless overridden per environment.', category: 'Auth', defaultValue: 'taskforce_session', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_ADMIN_PROXY_UPSTREAM_SESSION_COOKIE_PRODUCTION', description: 'Optional Production upstream session cookie name override for the admin proxy.', category: 'Auth', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_ADMIN_PROXY_UPSTREAM_SESSION_COOKIE_STAGING', description: 'Optional Staging upstream session cookie name override for the admin proxy.', category: 'Auth', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_ADMIN_PROXY_UPSTREAM_SESSION_COOKIE_PERFORMANCE', description: 'Optional Performance upstream session cookie name override for the admin proxy.', category: 'Auth', targets: ['server', 'all'] },
     { key: 'TASKFORCE_AUTH_SESSION_SECRET', description: 'Session signing secret.', category: 'Auth', secret: true, targets: ['server', 'all'] },
     { key: 'TASKFORCE_AUTH_SESSION_TTL_SECONDS', description: 'Session max age in seconds.', category: 'Auth', defaultValue: '2592000', targets: ['server', 'all'] },
     { key: 'TASKFORCE_AUTH_SESSION_SAMESITE', description: 'SameSite policy (Lax|Strict|None).', category: 'Auth', defaultValue: 'None', targets: ['server', 'all'] },
@@ -143,10 +149,16 @@ 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_MODEL_CONNECTION_STORAGE_PATH', description: 'Restricted durable volume root for isolated user-owned model provider credential homes.', 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'] },
@@ -160,6 +172,12 @@ const SPECS = [
     { key: 'TASKFORCE_ADMIN_AUDIT_SYNC_RETENTION_DAYS', description: 'Retention period for non-routine sync audit failures and exceptional events.', category: 'Security', defaultValue: '30', targets: ['server', 'all'] },
     { key: 'TASKFORCE_ADMIN_AUDIT_RETENTION_DAYS', description: 'Default retention period for administrative and security audit events.', category: 'Security', defaultValue: '365', targets: ['server', 'all'] },
     { key: 'TASKFORCE_SYNC_KEY', description: 'Optional sync encryption key.', category: 'Security', secret: true, targets: ['server', 'all'] },
+    { key: 'TASKFORCE_GITHUB_REVIEW_APP_ID', description: 'GitHub App identifier used for private-repository review evidence.', category: 'Security', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_GITHUB_REVIEW_APP_PRIVATE_KEY_BASE64', description: 'Base64-encoded GitHub App private key used only to mint short-lived installation tokens.', category: 'Security', secret: true, targets: ['server', 'all'] },
+    { key: 'TASKFORCE_PHASE_A_APPROVAL_ISSUER_ENABLED', description: 'Enable performance-cloud Phase A approval receipt issuance.', category: 'Security', defaultValue: 'false', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_PHASE_A_ISSUER_REDEMPTION_ENABLED', description: 'Expose the disabled performance-cloud Phase A issuer redemption boundary.', category: 'Security', defaultValue: 'false', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_PHASE_A_APPROVAL_SIGNING_KEY_ID', description: 'Active source-pinned Ed25519 key ID for performance Phase A approval receipts.', category: 'Security', targets: ['server', 'all'] },
+    { key: 'TASKFORCE_PHASE_A_APPROVAL_SIGNING_PRIVATE_KEY_PKCS8_BASE64', description: 'Base64-encoded PKCS#8 Ed25519 private key for performance Phase A approval receipts.', category: 'Security', secret: true, targets: ['server', 'all'] },
     { key: 'TASKFORCE_STRIPE_SECRET_KEY', description: 'Stripe secret API key used by server-side billing routes.', category: 'Security', secret: true, targets: ['server', 'all'] },
     { key: 'TASKFORCE_STRIPE_WEBHOOK_SECRET', description: 'Stripe webhook signing secret used to verify incoming webhooks.', category: 'Security', secret: true, targets: ['server', 'all'] },
     { key: 'TASKFORCE_BUILD_VERSION', description: 'Build version metadata.', category: 'Build', targets: ['server', 'all'] },
@@ -168,6 +186,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'] },
@@ -185,17 +205,22 @@ 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: 'SYNC_SOAK_SERVER_FAULT_PROFILE', description: 'Deterministic server-owned sync transport fault profile (none|operation-response-loss-once).', category: 'Soak', defaultValue: 'none', targets: ['soak', 'all'] },
+    { key: 'SYNC_SOAK_CLEAN_BASELINE_TIMEOUT_MS', description: 'Bounded wait for coordinator recovery and clean-baseline settlement.', category: 'Soak', defaultValue: '180000', 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'] }
 ];
@@ -255,6 +280,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',
@@ -345,6 +372,38 @@ function validateServerEnv(env, errors, warnings) {
     if (provider === 'postgres' && !hasValue(env, 'TASKFORCE_DATABASE_URL')) {
         errors.push('TASKFORCE_DATABASE_URL is required when TASKFORCE_DB_PROVIDER=postgres.');
     }
+    const hasGitHubReviewAppId = hasValue(env, 'TASKFORCE_GITHUB_REVIEW_APP_ID');
+    const hasGitHubReviewPrivateKey = hasValue(env, 'TASKFORCE_GITHUB_REVIEW_APP_PRIVATE_KEY_BASE64');
+    if (hasGitHubReviewAppId !== hasGitHubReviewPrivateKey) {
+        errors.push('TASKFORCE_GITHUB_REVIEW_APP_ID and TASKFORCE_GITHUB_REVIEW_APP_PRIVATE_KEY_BASE64 must be configured together.');
+    }
+    if (hasGitHubReviewPrivateKey) {
+        const encoded = String(env.TASKFORCE_GITHUB_REVIEW_APP_PRIVATE_KEY_BASE64 || '').trim();
+        const decoded = Buffer.from(encoded, 'base64').toString('utf8');
+        if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded) || !decoded.includes('-----BEGIN') || !decoded.includes('PRIVATE KEY-----')) {
+            errors.push('TASKFORCE_GITHUB_REVIEW_APP_PRIVATE_KEY_BASE64 must contain a base64-encoded PEM private key.');
+        }
+    }
+    const phaseAIssuerEnabled = parseBoolean(env.TASKFORCE_PHASE_A_APPROVAL_ISSUER_ENABLED) === true;
+    const phaseARedemptionEnabled = parseBoolean(env.TASKFORCE_PHASE_A_ISSUER_REDEMPTION_ENABLED) === true;
+    const hasPhaseAKeyId = hasValue(env, 'TASKFORCE_PHASE_A_APPROVAL_SIGNING_KEY_ID');
+    const hasPhaseAPrivateKey = hasValue(env, 'TASKFORCE_PHASE_A_APPROVAL_SIGNING_PRIVATE_KEY_PKCS8_BASE64');
+    if (phaseAIssuerEnabled || hasPhaseAKeyId || hasPhaseAPrivateKey) {
+        if (runtimeMode !== 'cloud' || deployment.cloudEnvironment !== 'performance') {
+            errors.push('Phase A approval receipt signing is allowed only in the performance cloud runtime.');
+        }
+    }
+    if (phaseARedemptionEnabled && (runtimeMode !== 'cloud' || deployment.cloudEnvironment !== 'performance')) {
+        errors.push('Phase A issuer redemption is allowed only in the performance cloud runtime.');
+    }
+    if (hasValue(env, 'TASKFORCE_PHASE_A_APPROVAL_ISSUER_ENABLED') || hasPhaseAKeyId || hasPhaseAPrivateKey) {
+        try {
+            resolveExecutorPhaseAApprovalSigningConfig(env);
+        }
+        catch (error) {
+            errors.push(String(error?.message || error));
+        }
+    }
     if (billingEnabled && !hasValue(env, 'TASKFORCE_STRIPE_SECRET_KEY')) {
         errors.push('TASKFORCE_STRIPE_SECRET_KEY is required when TASKFORCE_BILLING_ENABLED=true.');
     }

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.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);

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) => {

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,7 @@ 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) {
@@ -240,9 +273,7 @@ export function listDeletedTasksReadOnlyService(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)
             .filter((row) => row.deletedAt >= cutoff || durableDeleteOwnedTaskIds.has(row.taskId))
     };
 }